Color Learn3r

const Alexa = require('ask-sdk-core');
const Https = require('https');

const TARGET = process.env.npm_lifecycle_event;

// The namespace of the custom directive to be sent by this skill
const NAMESPACE = 'Custom.Mindstorms.Gadget';

// The name of the custom directive to be sent this skill
const NAME_CONTROL = 'control';

const COLORS = {
    'red': 0,
    'green': 60,
    'yellow': 120,
    'blue': 180,
    'white': 240,
    'black': 300
}

const HINTS = {
    'red': 'a tomato',
    'green': 'the grass',
    'yellow': 'the Sun',
    'blue': 'the ocean',
    'white': 'the snow',
    'black': `Santa's boots`
}

const STORIES = {
    'red': `Once upon a time an apple and a tomato argued who's the reddest fruit in the whole world. The tomato got so mad that it exploded and this is how the ketchup was invented.`,
    'green': `Things that are green: grass, aligator, lettuce, lime, cactus.`,
    'yellow': `Yellow... yellow Sun... yellow banana... yellow baby chick. We all live in a yellow submarine. Yellow submarine, yellow submarine...`,
    'blue': `Blue is the sky, blue is the ocean, the jeans are blue.`,
    'white': `There are lots of things that are W. H. I. T. E.: milk, clouds, snow, Santa's beard.`,
    'black': `Bats, scary cats are black. Santas boots are black.`
}

const ModeEnum = {
    'SHOW': 1,
    'STORY': 2,
    'QUIZ': 3
}
const ModeKey = 'Mode';
const ColorKey = 'Color';
const QuizListKey = 'QuizList';
const QuizIndexKey = 'QuizIndex';

const LaunchRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'LaunchRequest';
    },
    handle: async function (handlerInput) {

        let request = handlerInput.requestEnvelope;
        let { apiEndpoint, apiAccessToken } = request.context.System;
        console.log("Checking endpoint");
        let apiResponse = await getConnectedEndpoints(apiEndpoint, apiAccessToken);
        console.log("v1/endpoints response: " + JSON.stringify(apiResponse));
        if ((apiResponse.endpoints || []).length === 0) {
            return handlerInput.responseBuilder
                .speak(`I couldn't find an EV3 Brick connected to this Echo device. Please check to make sure your EV3 Brick is connected, and try again.`)
                .getResponse();
        }
        // Store the gadget endpointId to be used in this skill session
        let endpointId = apiResponse.endpoints[0].endpointId || [];
        putSessionAttribute(handlerInput, 'endpointId', endpointId);

        return handlerInput.responseBuilder
            .speak("Welcome to color learner. How can I help?")
            .reprompt("How can I help?")
            .getResponse();
    }
};

const ShowColorRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'ShowColorIntent';
    },
    handle: async function (handlerInput) {
        const attributesManager = handlerInput.attributesManager;
        // Set skill duration to 1 minute (2 30-seconds interval)
        putSessionAttribute(handlerInput, 'duration', 2);
        // Set the token to track the event handler
        const token = handlerInput.requestEnvelope.request.requestId;
        putSessionAttribute(handlerInput, 'token', token);
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];
        let color = Alexa.getSlotValue(handlerInput.requestEnvelope, ColorKey);
        color = color.toLowerCase();
        if (color in COLORS) {
            putSessionAttribute(handlerInput, ColorKey, color);
            putSessionAttribute(handlerInput, ModeKey, ModeEnum.SHOW);
            return handlerInput.responseBuilder
                .speak('<audio src="soundbank://soundlibrary/ui/gameshow/amzn_ui_sfx_gameshow_countdown_loop_32s_full_01"></audio>')
                .addDirective(buildShowColorDirective(endpointId, color))
                .addDirective(buildStartEventHandler(token, 60000, {}))
                .getResponse();
        } else {
            let colors = Object.keys(COLORS)
            let color_speach = colors.slice(0, -1).join(', ') + ' and ' + colors.slice(-1);
            return handlerInput.responseBuilder
                .speak(`Unknown color, I only know: ${color_speach}. What color do you want me to show you?`)
                .addElicitSlotDirective(ColorKey)
                .getResponse();
        }
    }
}
const TellStoryRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'TellStoryIntent';
    },
    handle: async function (handlerInput) {
        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];
        // Set skill duration to 1 minute (2 30-seconds interval)
        putSessionAttribute(handlerInput, 'duration', 2);
        // Set the token to track the event handler
        const token = handlerInput.requestEnvelope.request.requestId;
        putSessionAttribute(handlerInput, 'token', token);
        let color = Alexa.getSlotValue(handlerInput.requestEnvelope, ColorKey);
        color = color.toLowerCase();
        if (color in COLORS) {
            putSessionAttribute(handlerInput, ColorKey, color);
            putSessionAttribute(handlerInput, ModeKey, ModeEnum.STORY);
            return handlerInput.responseBuilder
                .speak('<audio src="soundbank://soundlibrary/ui/gameshow/amzn_ui_sfx_gameshow_countdown_loop_32s_full_01"></audio>')
                .addDirective(buildShowColorDirective(endpointId, color))
                .addDirective(buildStartEventHandler(token, 60000, {}))
                .getResponse();
        } else {
            let colors = Object.keys(COLORS)
            let color_speach = colors.slice(0, -1).join(', ') + ' and ' + colors.slice(-1);
            return handlerInput.responseBuilder
                .speak(`Unknown color, I only know: ${color_speach}. What should it be?`)
                .addElicitSlotDirective(ColorKey)
                .getResponse();
        }
    }
};

const QuizColorRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'QuizColorIntent';
    },
    handle: async function (handlerInput) {
        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];
        // Set skill duration to 1 minute (2 30-seconds interval)
        putSessionAttribute(handlerInput, 'duration', 2);
        // Set the token to track the event handler
        const token = handlerInput.requestEnvelope.request.requestId;
        putSessionAttribute(handlerInput, 'token', token);
        let color = Alexa.getSlotValue(handlerInput.requestEnvelope, ColorKey);
        let index = parseInt(attributesManager.getSessionAttributes()[QuizIndexKey]);
        let color_list = JSON.parse(attributesManager.getSessionAttributes()[QuizListKey]);
        let correct_answer = color_list[index];
        if (color === correct_answer) {
            if (index + 1 >= Object.keys(COLORS).length) {
                putSessionAttribute(handlerInput, ModeKey, null);
                return handlerInput.responseBuilder
                    .speak(`Congratulation. You said ${correct_answer}. You finished the quiz! How can I help next?`)
                    .reprompt('How can I help?')
                    .getResponse();
            } else {
                putSessionAttribute(handlerInput, QuizIndexKey, index + 1);
                return handlerInput.responseBuilder
                    .speak(`Congratulation. You said ${correct_answer}. Next one.` +
                        '<audio src="soundbank://soundlibrary/ui/gameshow/amzn_ui_sfx_gameshow_countdown_loop_32s_full_01"></audio>')
                    .addDirective(buildShowColorDirective(endpointId, color_list[index + 1]))
                    .addDirective(buildStartEventHandler(token, 60000, {}))
                    .getResponse();
            }
        } else {
            return handlerInput.responseBuilder
                .speak(`Incorrect. Try again. It's the color of ${HINTS[correct_answer]}.`)
                .reprompt('What color is this?')
                .addElicitSlotDirective(ColorKey)
                .getResponse();
        }

    }
};

const QuizRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'QuizIntent';
    },
    handle: async function (handlerInput) {
        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];
        // Set skill duration to 1 minute (2 30-seconds interval)
        putSessionAttribute(handlerInput, 'duration', 2);
        // Set the token to track the event handler
        const token = handlerInput.requestEnvelope.request.requestId;
        putSessionAttribute(handlerInput, 'token', token);
        const color_list = shuffle_random(Object.keys(COLORS));
        putSessionAttribute(handlerInput, QuizListKey, JSON.stringify(color_list));
        putSessionAttribute(handlerInput, QuizIndexKey, 0);
        putSessionAttribute(handlerInput, ModeKey, ModeEnum.QUIZ);
        return handlerInput.responseBuilder
            .speak('<audio src="soundbank://soundlibrary/ui/gameshow/amzn_ui_sfx_gameshow_countdown_loop_32s_full_01"></audio>')
            .addDirective(buildShowColorDirective(endpointId, color_list[0]))
            .addDirective(buildStartEventHandler(token, 60000, {}))
            .getResponse();
    }
};

const HelpIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.HelpIntent';
    },
    handle(handlerInput) {
        let colors = Object.keys(COLORS)
        let color_speach = colors.slice(0, -1).join(', ') + ' and ' + colors.slice(-1);
        const speakOutput = `I can show you colors and tell you story about them! `
            + `The colors that I know are ${color_speach}. I can quiz you. How can I help?`;
        return handlerInput.responseBuilder
            .speak(speakOutput)
            .reprompt(speakOutput)
            .getResponse();
    }
};
const CancelAndStopIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && (Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.CancelIntent'
                || Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.StopIntent');
    },
    handle(handlerInput) {
        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];
        return handlerInput.responseBuilder
            .speak('Goodbye')
            .addDirective(buildStopDirective(endpointId))
            .getResponse();
    }
};
const YesIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.YesIntent';
    },
    handle(handlerInput) {
        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];

        const mode = attributesManager.getSessionAttributes()[ModeKey] || null;
        const color = attributesManager.getSessionAttributes()[ColorKey];

        if (mode === ModeEnum.STORY) {
            return handlerInput.responseBuilder
                .addDelegateDirective({
                    name: 'TellStoryIntent',
                    confirmationStatus: 'CONFIRMED',
                    slots:
                    {
                        Color:
                        {
                            name: ColorKey,
                            value: color,
                            confirmationStatus: 'NONE'
                        }
                    }
                })
                .getResponse();
        }

        return handlerInput.responseBuilder
            .speak('How can I help?')
            .reprompt('How can I help?')
            .getResponse();
    }
};

const NoIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.NoIntent';
    },
    handle(handlerInput) {
        putSessionAttribute(handlerInput, ModeKey, null);
        return handlerInput.responseBuilder
            .speak('How can I help?')
            .reprompt('How can I help?')
            .getResponse();
    }
};

const SessionEndedRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'SessionEndedRequest';
    },
    handle(handlerInput) {
        const reason = handlerInput.requestEnvelope.request.reason;
        console.log("==== SESSION ENDED WITH REASON ======");
        console.log(reason);
        return handlerInput.responseBuilder.getResponse();
    }
};

const RequestInterceptor = {
    process(handlerInput) {
        let { attributesManager, requestEnvelope } = handlerInput;
        let sessionAttributes = attributesManager.getSessionAttributes();

        // Log the request for debugging purposes.
        console.log(`==Request==${JSON.stringify(requestEnvelope)}`);
        console.log(`==SessionAttributes==${JSON.stringify(sessionAttributes, null, 2)}`);
    }
};

const ResponseInterceptor = {
    process(handlerInput) {

        let { attributesManager, responseBuilder } = handlerInput;
        let response = responseBuilder.getResponse();
        let sessionAttributes = attributesManager.getSessionAttributes();

        // Log the response for debugging purposes.
        console.log(`==Response==${JSON.stringify(response)}`);
        console.log(`==SessionAttributes==${JSON.stringify(sessionAttributes, null, 2)}`);
    }
};

const EventsReceivedRequestHandler = {
    // Checks for a valid token and endpoint.
    canHandle(handlerInput) {
        let { request } = handlerInput.requestEnvelope;
        console.log('Request type: ' + Alexa.getRequestType(handlerInput.requestEnvelope));
        if (request.type !== 'CustomInterfaceController.EventsReceived') return false;

        const attributesManager = handlerInput.attributesManager;
        let sessionAttributes = attributesManager.getSessionAttributes();
        let customEvent = request.events[0];

        // Validate event token
        if (sessionAttributes.token !== request.token) {
            console.log("Event token doesn't match. Ignoring this event");
            return false;
        }

        // Validate endpoint
        let requestEndpoint = customEvent.endpoint.endpointId;
        if (requestEndpoint !== sessionAttributes.endpointId) {
            console.log("Event endpoint id doesn't match. Ignoring this event");
            return false;
        }
        return true;
    },
    handle(handlerInput) {

        console.log("== Received Custom Event ==");
        let customEvent = handlerInput.requestEnvelope.request.events[0];
        let payload = customEvent.payload;
        let name = customEvent.header.name;

        const attributesManager = handlerInput.attributesManager;
        const mode = attributesManager.getSessionAttributes()[ModeKey] || null;
        const color = attributesManager.getSessionAttributes()[ColorKey];

        if (name === 'notification' && payload.done === true) {
            if (mode === ModeEnum.STORY) {
                putSessionAttribute(handlerInput, ModeKey, null);
                return handlerInput.responseBuilder
                    .speak(`${STORIES[color]} How can I help next?`, 'REPLACE_ALL')
                    .reprompt('How can I help?')
                    .withShouldEndSession(false)
                    .addDirective(buildStopEventHandlerDirective(handlerInput))
                    .getResponse();
            } else if (mode === ModeEnum.SHOW) {
                putSessionAttribute(handlerInput, ModeKey, ModeEnum.STORY);
                return handlerInput.responseBuilder
                    .speak(`Done. Do you want a story about color ${color}?`, 'REPLACE_ALL')
                    .reprompt('How can I help?')
                    .withShouldEndSession(false)
                    .addDirective(buildStopEventHandlerDirective(handlerInput))
                    .getResponse();
            } else if (mode === ModeEnum.QUIZ) {
                return handlerInput.responseBuilder
                    .speak(`What color is this?`, 'REPLACE_ALL')
                    .reprompt('What color is this?')
                    .withShouldEndSession(false)
                    .addDirective(buildStopEventHandlerDirective(handlerInput))
                    .getResponse();
            } else {
                return handlerInput.responseBuilder
                    .speak(`How can I help?`, 'REPLACE_ALL')
                    .reprompt('How can I help?')
                    .withShouldEndSession(false)
                    .addDirective(buildStopEventHandlerDirective(handlerInput))
                    .getResponse();
            }
        }
        return handlerInput.responseBuilder
            .speak('Unknown event. How can I help?')
            .reprompt('How can I help?')
            .withShouldEndSession(false)
            .getResponse();
    }
};
const ExpiredRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'CustomInterfaceController.Expired'
    },
    handle(handlerInput) {
        console.log("== Custom Event Expiration Input ==");

        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];

        // Set the token to track the event handler
        const token = handlerInput.requestEnvelope.request.requestId;
        putSessionAttribute(handlerInput, 'token', token);

        let duration = attributesManager.getSessionAttributes().duration || 0;
        if (duration > 0) {
            putSessionAttribute(handlerInput, 'duration', --duration);
            // Extends skill session
            return handlerInput.responseBuilder
                .addDirective(buildStartEventHandler(token, 60000, {}))
                .getResponse();
        }
        else {
            // End skill session
            return handlerInput.responseBuilder
                .speak("Skill duration expired. Goodbye.")
                .addDirective(buildStopDirective(endpointId))
                .withShouldEndSession(true)
                .getResponse();
        }
    }
};

// The intent reflector is used for interaction model testing and debugging.
// It will simply repeat the intent the user said. You can create custom handlers
// for your intents by defining them above, then also adding them to the request
// handler chain below.
const IntentReflectorHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest';
    },
    handle(handlerInput) {
        const intentName = Alexa.getIntentName(handlerInput.requestEnvelope);
        const speakOutput = `You just triggered ${intentName}`;

        return handlerInput.responseBuilder
            .speak(speakOutput)
            .reprompt("I don't understand this command, try again")
            .getResponse();
    }
};

// Generic error handling to capture any syntax or routing errors. If you receive an error
// stating the request handler chain is not found, you have not implemented a handler for
// the intent being invoked or included it in the skill builder below.
const ErrorHandler = {
    canHandle() {
        return true;
    },
    handle(handlerInput, error) {
        console.log(`~~~~ Error handled: ${error.stack}`);
        const speakOutput = `Sorry, I had trouble doing what you asked. Please try again.`;

        return handlerInput.responseBuilder
            .speak(speakOutput)
            .reprompt(speakOutput)
            .getResponse();
    }
};

/**
 * A convenience routine to add the a key-value pair to the session attribute.
 * @param handlerInput - the context from Alexa Service
 * @param key - the key to be added
 * @param value - the value be added
 */
function putSessionAttribute(handlerInput, key, value) {
    const attributesManager = handlerInput.attributesManager;
    let sessionAttributes = attributesManager.getSessionAttributes();
    sessionAttributes[key] = value;
    attributesManager.setSessionAttributes(sessionAttributes);
}

/**
 * To get a list of all the gadgets that meet these conditions,
 * Call the Endpoint Enumeration API with the apiEndpoint and apiAccessToken to
 * retrieve the list of all connected gadgets.
 *
 * @param {string} apiEndpoint - the Endpoint API url
 * @param {string} apiAccessToken  - the token from the session object in the Alexa request
 * @see {@link https://developer.amazon.com/docs/alexa-gadgets-toolkit/send-gadget-custom-directive-from-skill.html#call-endpoint-enumeration-api}
 */
function getConnectedEndpoints(apiEndpoint, apiAccessToken) {

    // The preceding https:// need to be stripped off before making the call
    apiEndpoint = (apiEndpoint || '').replace('https://', '');
    return new Promise(((resolve, reject) => {

        const options = {
            host: apiEndpoint,
            path: '/v1/endpoints',
            method: 'GET',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': 'Bearer ' + apiAccessToken
            }
        };

        const request = Https.request(options, (response) => {
            response.setEncoding('utf8');
            let returnData = '';
            response.on('data', (chunk) => {
                returnData += chunk;
            });

            response.on('end', () => {
                resolve(JSON.parse(returnData));
            });

            response.on('error', (error) => {
                reject(error);
            });
        });
        request.end();
    }));
}

function buildShowColorDirective(endpointId, color) {
    return {
        type: 'CustomInterfaceController.SendDirective',
        header: {
            name: NAME_CONTROL,
            namespace: NAMESPACE
        },
        endpoint: {
            endpointId: endpointId
        },
        payload: {
            type: 'show',
            color: color
        }
    };
}

function buildStopDirective(endpointId) {
    return {
        type: 'CustomInterfaceController.SendDirective',
        header: {
            name: NAME_CONTROL,
            namespace: NAMESPACE
        },
        endpoint: {
            endpointId: endpointId
        },
        payload: {
            type: 'stop'
        }
    };
}

function buildStartEventHandler(token, timeout = 30000, payload) {
    return {
        type: "CustomInterfaceController.StartEventHandler",
        token: token,
        expiration: {
            durationInMilliseconds: timeout,
            expirationPayload: payload
        }
    };
}

function buildStopEventHandlerDirective(handlerInput) {
    let token = handlerInput.attributesManager.getSessionAttributes().token || '';
    return {
        "type": "CustomInterfaceController.StopEventHandler",
        "token": token
    }
}

function shuffle_random(unshuffled) {
    return unshuffled
        .map((a) => ({ sort: Math.random(), value: a }))
        .sort((a, b) => a.sort - b.sort)
        .map((a) => a.value);
}


// The SkillBuilder acts as the entry point for your skill, routing all request and response
// payloads to the handlers above. Make sure any new handlers or interceptors you've
// defined are included below. The order matters - they're processed top to bottom.
exports.handler = Alexa.SkillBuilders.custom()
    .addRequestHandlers(
        LaunchRequestHandler,
        ShowColorRequestHandler,
        TellStoryRequestHandler,
        YesIntentHandler,
        NoIntentHandler,
        QuizRequestHandler,
        QuizColorRequestHandler,
        EventsReceivedRequestHandler,
        ExpiredRequestHandler,
        HelpIntentHandler,
        CancelAndStopIntentHandler,
        SessionEndedRequestHandler,
        IntentReflectorHandler, // make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers
    )
    .addRequestInterceptors(RequestInterceptor)
    .addResponseInterceptors(ResponseInterceptor)
    .addErrorHandlers(ErrorHandler)
    .lambda();