import {parsePolicy} from './cspPolicyParser.js';
import {HtmlRewritingStream} from 'html-rewriter';
import {httpRequest} from 'http-request';
import {createResponse} from 'create-response';
import {crypto} from 'crypto';
import {btoa} from "encoding";
import {logger} from 'log';

export async function responseProvider(request) {

    //Step 1: Calculate the Nonce
    let array = new Uint32Array(1);
    crypto.getRandomValues(array);
    let stringToEncode = array[0].toString();
    let encodedData = btoa(stringToEncode);
    let headerNonce = 'nonce-' + encodedData;
    logger.log('nonce: %s', headerNonce);

    //Step 2: Replace the origin nonce with our generated nonce in the CSP response header
    const headers = request.getHeaders();
    let options = {};
    let htmlResponse = await httpRequest("/xyz/csp/index.html", options);
    if (!htmlResponse.ok) {
        return createResponse(500, {}, `Failed to fetch doc: ${htmlResponse.status}`);
    }
    let responseHeaders = htmlResponse.getHeaders();
    let originCSPHeader = htmlResponse.getHeader('Content-Security-Policy')[0];
    const parsedPolicy = parsePolicy(originCSPHeader);
    let parsedPolicyElement = parsedPolicy['script-src'][0].toString();
    let newCspHeader = originCSPHeader.replace(parsedPolicyElement, "'" + headerNonce + "'");
    responseHeaders['content-security-policy'] = [newCspHeader];

    //Step 3: Rewrite the HTML with our generated nonce
    let rewriter = new HtmlRewritingStream();
    rewriter.onElement('[nonce=' + parsedPolicyElement + ']', el => {
        el.setAttribute('nonce', encodedData, {quote: "'"})
    });

    return createResponse(200, getSafeResponseHeaders(responseHeaders), htmlResponse.body.pipeThrough(rewriter));
}

// Add/remove unsafe headers from this list as required. This headers will be removed form origin response before sending to client.
const UNSAFE_RESPONSE_HEADERS = ['content-length', 'transfer-encoding', 'connection', 'vary',
    'accept-encoding', 'content-encoding', 'keep-alive',
    'proxy-authenticate', 'proxy-authorization', 'te', 'trailers', 'upgrade', 'host'];

function getSafeResponseHeaders(headers) {
    for (let unsafeResponseHeader of UNSAFE_RESPONSE_HEADERS) {
        if (unsafeResponseHeader in headers) {
            delete headers[unsafeResponseHeader];
        }
    }
    return headers;
}

import { logger } from 'log';
import { HtmlRewritingStream } from 'html-rewriter';
import { httpRequest } from 'http-request';
import { createResponse } from 'create-response';
import URLSearchParams from 'url-search-params';
export async function responseProvider(request) {

  let jsonresponse = await httpRequest('/xyz/menujson.json');
  let menujson = await jsonresponse.json();

  let rewriter = new HtmlRewritingStream();

  rewriter.onElement('section', el => {
    el.before(`
${menujson[0].name}
`);
    el.after(`
${menujson[0].items[3].item}
${menujson[0].items[3].price}
`);
    el.prepend(`
${menujson[0].items[2].item}
${menujson[0].items[2].price}
`);
    el.append(`
${menujson[0].items[1].item}
${menujson[0].items[1].price}
`);
    el.replaceChildren(`
${menujson[0].items[0].item}
${menujson[0].items[0].price}
`);
  });

  if(getLoggedInUser(request)){
    rewriter.onElement('h1', el => {
      el.after('
Special 20% discount member offer applied!
');
    });
  }

  let subrequestHeaders = {"X-Subrequest": ["true"]};
  let htmlResponse = await httpRequest("/xyz/template.html", {headers: subrequestHeaders});
  if (!htmlResponse.ok) {
    return createResponse(500, {}, `Failed to fetch doc: ${htmlResponse.status}`);
  }
  return createResponse(200, {}, htmlResponse.body.pipeThrough(rewriter));
}

function getLoggedInUser(request){
  //Your logic which could return boolean value.
}

import URLSearchParams from 'url-search-params';

export function onClientRequest(request) {
    var params = new URLSearchParams(request.query);
    if (params.get('key') === 'abc123') {
        request.respondWith(200, {
                'Content-Type': ['text/html']
            },
            'Welcome to the conference.Here are the venue details:123 Main Street, San Francisco, CADec, 6th 2019 10pm sharp');
    } else {
        request.respondWith(200, {
                'Content-Type': ['text/html']
            },
            'You have entered an incorrect code.');
    }
}

import { httpRequest } from 'http-request';
import { createResponse } from 'create-response';

const endPoint1 = '/api/example/endpoint1';
const endPoint2 = '/api/example/endpoint2';
const endPoint3 = '/api/example/endpoint3';

async function getJSON(url) {
    const response = await httpRequest(`${url}`);
    if (response.ok) {
        return await response.json();
    } else {
        return {
            error: `Failed to return ${url}`
        };
    }
}

// The responseProvide function generates a response, acting as a "surrogate origin".
// The response may be cached according to the caching rules configured in the property.
export async function responseProvider(request) {
    const result = {};

    // Make all requests in parallel to retrieve content.
    const endPointResult1 = getJSON(endPoint1).then(json => {
        result.endPoint1 = json;
    });
    const endPointResult2 = getJSON(endPoint2).then(json => {
        result.endPoint2 = json;
    });
    const endPointResult3 = getJSON(endPoint3).then(json => {
        result.endPoint3 = json;
    });

    // Wait for all requests to complete.
    await Promise.all([endPointResult1, endPointResult2, endPointResult3]);

    // Return merged JSON as the response.
    return Promise.resolve(createResponse(
        200, {
            'Content-Type': ['application/json']
        },
        JSON.stringify(result)
    ));
}

// List of currently US embargoed countries, plus N/A indicating no country data found (rare, if any)
const embargoedCountries = ['IR', 'KP', 'SY', 'SD', 'CU', 'VE', 'N/A'];

export function onClientRequest(request) {
    // Collect the end user's country based on Akamai EdgeScape data
    const country = (request.userLocation.country) ? request.userLocation.country : 'N/A';

    // Check if end user's country is in embargo list
    const embargoed = embargoedCountries.includes(country);

    // Provide appropriate messaging based on embargo status
    if (!embargoed) {
        request.respondWith(200, {
                'Content-Type': ['text/html;charset=utf-8']
            },
            'Hello ' + country + ' from Akamai EdgeWorkers!');
    } else {
        request.respondWith(403, {
                'Content-Type': ['text/html;charset=utf-8']
            },
            'Sorry, users from ' + country + ' may not view this content', 'EW-embargo');
    }
}

import { Cookies, SetCookie } from 'cookies';

		 export function onClientRequest (request) {
		   const cookies = new Cookies(request.getHeader('Cookie'));
		   var cartCookie = cookies.get('cart');

		   if (!cartCookie) {
		     request.respondWith(200, { 'Content-Type': ['application/json; charset=utf-8'] }, '{}');
		   }
		 }

/*
onOriginResponse: This event happens as the origin response is created.
The event only happens if the response is not served from cache and not constructed on the edge.
Use this event if you want to modify the response before it is cached.
*/
export function onOriginResponse(request, response) {
    response.addHeader('Origin-Response-Status', response.status);

    if (response.status === 503 || response.status === 500) {
        var retry = parseInt(response.getHeader('Retry-After')) || 10;
        request.respondWith(200, {
                'Content-Type': ['text/html']
            }, ' setTimeout(function () 
            //{ window.location.href="' + escape(request.path) + '"; }, ' + retry + '*1000); 
            The origin server is currently overloaded, please retry in ' + retry + '
            seconds ');
        }
    }

import { ReadableStream,WritableStream } from 'streams';
import { httpRequest } from 'http-request';
import { createResponse } from 'create-response';
import { TextEncoderStream,TextDecoderStream } from 'text-encode-transform';
import { FindAndReplaceStream } from 'find-replace-stream.js';
import { logger } from 'log';

export function responseProvider(request) {
    // Get text to be searched for and new replacement text from Property Manager variables in the request object.
    // const tosearchfor = request.getVariable('PMUSER_EWSEARCH');
    // const newtext = request.getVariable('PMUSER_EWNEWTEXT');
    // Set to 0 to replace all, otherwise a number larger than 0 to limit replacements
    const tosearchfor = 'This is the original string';
    var newtext = 'This is the updated string';
    const howManyReplacements = 1;

    return httpRequest(`${request.scheme}://${request.host}${request.url}`).then(response => {
        return createResponse(
            response.status,
            response.headers,
            response.body.pipeThrough(new TextDecoderStream())
            .pipeThrough(new FindAndReplaceStream(tosearchfor, newtext, howManyReplacements))
            .pipeThrough(new TextEncoderStream())
        );
    });
}

import { ReadableStream, WritableStream } from 'streams';
import { httpRequest } from 'http-request';
import { createResponse } from 'create-response';
import { TextEncoderStream, TextDecoderStream } from 'text-encode-transform';

class HTMLStream {
    constructor() {
        let readController = null;
        this.readable = new ReadableStream({
            start(controller) {
                readController = controller;
            }
        });

        async function handleTemplate(text) {
            const startIndex = text.indexOf(tag);
            if (startIndex === -1) {
                readController.enqueue(text);
            } else {
                readController.enqueue(text.substring(0, startIndex));
                readController.enqueue(script);
                readController.enqueue(text.substring(startIndex));
            }
        }

        let completeProcessing = Promise.resolve();

        this.writable = new WritableStream({
            write(text) {
                completeProcessing = handleTemplate(text, 0);
            },
            close(controller) {
                completeProcessing.then(() => readController.close());
            }
        });
    }
}

export function responseProvider(request) {
    return httpRequest(`${request.scheme}://${request.host}${request.url}`).then(response => {

        // Get headers from response
        let headers = response.getHeaders();
        // Remove content-encoding header.  The response stream from EdgeWorkers is not encoded.
        // If original response contains `Content-Encoding: gzip`, 
        then the Content - Encoding header does not match the actual encoding.
        delete headers["content-encoding"];
        // Remove `Content-Length` header.  Modifying HTML is likely to change the content length.
        // Leaving the Length of the original content would be incorrect.
        delete headers["content-length"];

        return createResponse(
            response.status,
            headers,
            response.body.pipeThrough(new TextDecoderStream())
            .pipeThrough(new HTMLStream())
            .pipeThrough(new TextEncoderStream())
        );
    });
}

// Import cookies library to provide helper functions
import { SetCookie } from 'cookies';
import { salesRegions } from 'data.js';

// Helper function to find a sales region by state.
function findRegionByState(state) {
    return salesRegions.find((region) => region.states.includes(state));
}

// Add cookie in the outgoing response to the browser
export function onClientResponse(request, response) {
    // Retrieve user location from the request object
    const userLocation = request.userLocation;

    // Extract country, region (e.g., U.S. state), and city from userLocation
    const country = userLocation.country || 'N/A';
    const region = userLocation.region || 'N/A';
    const city = userLocation.city || 'N/A';
    const salesRegion = findRegionByState(region);

    // Create a cookie, with location fields separate by '+'
    const locationCookieValue = `${country}+${region}+${city}`;

    // Create cookie with an expiration of 1 day (86,400 seconds)
    var cookie = new SetCookie({
        name: 'location',
        value: locationCookieValue,
        path: '/',
        maxAge: 86400
    });

    // Add cookie header to outgoing  response
    response.addHeader('Set-Cookie', cookie.toHeader());

    //  If sales region is found, then also add the salesRegion cookie
    if (salesRegion) {
        const regionDataCookieValue = `${salesRegion.name}:${salesRegion.population}`;
        var salesRegionCookie = new SetCookie({
            name: 'salesRegion',
            value: regionDataCookieValue,
            path: '/',
            maxAge: 86400
        });
        response.addHeader('Set-Cookie', salesRegionCookie.toHeader());
    }
}

export function onClientRequest(request) {
    if (request.device.isMobile) {
        request.route({
            path: '/mobile' + request.path
        });
    } else if (request.device.isTablet) {
        request.route({
            path: '/tablet' + request.path
        });
    }
}

export function onClientRequest(request) {
    request.setVariable('PMUSER_DEVICETYPE', 'Desktop');
    if (request.device.isMobile) {
        request.setVariable('PMUSER_DEVICETYPE', 'Mobile');
    } else if (request.device.isTablet) {
        request.setVariable('PMUSER_DEVICETYPE', 'Tablet');
    }
    request.cacheKey.includeVariable('PMUSER_DEVICETYPE');
}

import URLSearchParams from 'url-search-params';

		 import KDBush from 'kdbush';
		 import geokdbush from 'geokdbush';

		 import locations from './data/locations.json';

		 // Initialize index of locations
		 const indexedLocations = new KDBush(locations.elements, (p) => p.lon, (p) => p.lat);

		 export function onClientRequest (request) {
		   // Extract longitude and latitude from query string
		   const params = new URLSearchParams(request.query);
		   const lat = Number(params.get('lat'));
		   const lon = Number(params.get('lon'));

		   // Respond with an error if lat or lon are not passed in.
		   if (!lon || !lat) {
		     request.respondWith(
		       400,
		       { 'Content-Type': ['application/json;charset=utf-8'] },
		       JSON.stringify({ error: 'lat and lon parameters must be provided' })
		     );
		     return;
		   }

		   if (!nearest) {
		     request.respondWith(
		       400,
		       { 'Content-Type': ['application/json;charset=utf-8'] },
		       JSON.stringify({ error: `Error locating nearby locations. lat:${lat}, lon:${lon}` })
		     );
		     return;
		   }

		   const result = [];
		   for (var i = 0; i < nearest.length; i++) {
		     const location = nearest[i];
		     // calulate distance and convert to miles
		     const distance = geokdbush.distance(lon, lat, location.lon, location.lat) / 1.609;
		     // add distance and location to the result
		     result.push({ distance: distance, location: location });
		   }

		   // Respond with json result containing nearest locations
		   request.respondWith(
		     200,
		     { 'Content-Type': ['application/json;charset=utf-8'] },
		     JSON.stringify(result, null, 2));
		 }

import URLSearchParams from 'url-search-params';
import { default as searchterms } from './searchterms.js';

export function onClientRequest(request) {
    const params = new URLSearchParams(request.query);
    const jsonContentType = {
        'Content-Type': ['application/json;charset=utf-8']
    };
    const searchResult = searchterms[params.get('term').toLowerCase()];
    if (searchResult) {
        request.respondWith(200, jsonContentType, JSON.stringify(searchResult));
    }
}

import { TransformStream } from "streams";
import { httpRequest } from "http-request";
import { createResponse } from "create-response";
import URLSearchParams from "url-search-params";

function str2uint8arr(s) {
    return Uint8Array.from(Array.from(s, (x) => x.charCodeAt(0)))
}

export function responseProvider(request) {
    let params = new URLSearchParams(request.query);
    let callbackName = params.get("callback");
    params.delete("callback");

    const jsonpTransformer = new TransformStream({
        transform(chunk, controller) {
            if (chunk) {
                controller.enqueue(chunk);
            }
        },
        start(controller) {
            controller.enqueue(str2uint8arr(callbackName + "("));
        },
        flush(controller) {
            controller.enqueue(str2uint8arr(")"));
        }
    });

    const options = {
        'headers': {
            'Accept': 'application/json'
        }
    };
    return httpRequest(`${request.scheme}:
		 	//${request.host}${request.path}?${params.toString()}`, options).then((response) => {

        // Get headers from response
        let headers = response.getHeaders();
        // Remove content-encoding header.  The response stream from EdgeWorkers is not encoded.
        // If original response contains `Content-Encoding: gzip`, 
        then the Content - Encoding header does not match the actual encoding.
        delete headers["content-encoding"];
        // Remove `Content-Length` header.  Modifying JSON is likely to change the content length.
        // Leaving the Length of the original content would be incorrect.
        delete headers["content-length"];

        return createResponse(
            response.status,
            headers,
            response.body.pipeThrough(jsonpTransformer)
        );
    });
}

import { Cookies,SetCookie } from 'cookies';
import URLSearchParams from 'url-search-params';

// ====== Begin Configuration ====== //
// Update constants below to configure A/B logic

/** Probability that a user is added to the "A" group.  0.5 = 50% */
const probabilityOfA = 0.5;

/** Name of cookie that stores A/B group assignment. */
const cookieName = 'testGroup';

/**
 * Name of query parameter that contains A/B group assignment
 * This query parameter will be added to the outgoing onClientRequest.
 * The query parameter can be added to the incoming request to force A/B group assignment.
 */
const queryParamName = 'testGroup';

/** Cookie and query string value to use for users in the "A" group. */
const groupAValue = 'A';

/** Cookie and query string value to use for users in the "B" group. */
const groupBValue = 'B';

// ====== End Configuration ====== //

export function onClientRequest(request) {
    const cookies = new Cookies(request.getHeader('Cookie'));
    const params = new URLSearchParams(request.query);

    // Initialize existing and reult group value from the request cookie
    const existingGroupValue = cookies.get(cookieName);
    let resultGroupValue = existingGroupValue;

    // override result group value if forced by query parameter
    const paramValue = params.get(queryParamName);
    if (paramValue) {
        resultGroupValue = paramValue;
    }

    // If no group value has been assigned,
    // then randomly choose one based on configured percentage
    if (!resultGroupValue) {
        if (Math.random() <= probabilityOfA) {
            resultGroupValue = groupAValue;
        } else {
            resultGroupValue = groupBValue;
        }
    }

    // If group value if different than the existing cookie,
    // then replace the incoming cookie with the new value.
    if (resultGroupValue != existingGroupValue) {
        cookies.delete(cookieName);
        cookies.add(cookieName, resultGroupValue);
        request.setHeader('Cookie', cookies.toHeader());
    }

    // If the group was not already included in the incoming query parameter,
    // then add the query parameter to the query string.
    // The query parameter allows the origin to respond with appropriate logic
    // and ensures the A/B group is included in the cache key.
    if (!paramValue) {
        params.append(queryParamName, resultGroupValue);
        request.route({
            query: params.toString()
        });
    }
}

export function onClientResponse(request, response) {
    // Set a response cookie with the A/B group based on
    // the request cookie  set in the onClientRequest handler.
    const cookies = new Cookies(request.getHeader('Cookie'));
    const cookieValue = cookies.get(cookieName);
    const setCookie = new SetCookie({
        name: cookieName,
        value: cookieValue
    });
    response.setHeader('Set-Cookie', setCookie.toHeader());
}

import { Cookies, SetCookie} from 'cookies';
import URLSearchParams from 'url-search-params';

// ====== Begin Configuration ====== //

const groups = [{
        // "test1" is a simple test that chooses between 2 variants with a 50/50 split
        // The chosen variant will be included in both:
        //   * a query string parameter that is sent to the origin a
        //   * a cookie that is sent to the browser
        testName: 'test1',
        cookieName: 'test1',
        queryParamName: 'test1',
        variants: [{
                variantName: '1a'
            },
            {
                variantName: '1b'
            }
        ]
    },
    {
        // "test2" is a more complex test that chooses between 3 variants
        // variants "2b" and "2c" are twice as likely to be selected as "2a"
        //  Custom request actions are used to
        //  * route to a different origin in variants "2a" and "2b"
        //  * construct a response at the Edge in variant "2c"
        // Custom response actions are used to add a response header in each variant
        testName: 'test2',
        cookieName: 'test2',
        queryParamName: 'test2',
        variants: [{
                variantName: '2a',
                weight: 1,
                requestAction(request) {
                    request.route({
                        origin: 'microservice1'
                    });
                },
                responseAction(request, response) {
                    response.addHeader('X-Variant', '2a');
                }
            },
            {
                variantName: '2b',
                weight: 2,
                requestAction(request) {
                    request.route({
                        origin: 'microservice2'
                    });
                },
                responseAction(request, response) {
                    response.addHeader('X-Variant', '2b');
                }
            },
            {
                variantName: '2c',
                weight: 2,
                requestAction(request) {
                    request.respondWith(
                        200, {
                            'Content-Type': ['application/json']
                        },
                        JSON.stringify({
                            heroImageUrl: '/assets/images/hero2c.jpg',
                            text: 'This is variant 2c, generated from an Akamai EdgeWorker'
                        }));
                },
                responseAction(request, response) {
                    response.addHeader('X-Variant', '2c');
                }
            }
        ]
    }
];

// ====== End Configuration ====== //

/**
 * Process each test group to convert "weights" into a "range".
 * The range will be between 0-1, with the upper bound stored in each group.
 * This facilitates selection via Math.random()
 */
function processGroups() {
    groups.forEach((group) => {
        const sumOfWeights = group.variants.reduce((currValue, variant) =>
            currValue + (variant.weight || 1),
            0
        );

        let upperBound = 0;
        group.variants.forEach((variant) => {
            upperBound += (variant.weight || 1) / sumOfWeights;
            variant.upperBound = upperBound;
        });
    });
}

processGroups(groups);

export function onClientRequest(request) {
    const cookies = new Cookies(request.getHeader('Cookie'));
    const params = new URLSearchParams(request.query);

    groups.forEach((group) => {
        const cookieName = group.cookieName;
        const queryParamName = group.queryParamName;

        let resultVariant;

        // Initialize existing and reult variant value from the request cookie
        const existingVariantName = cookies.get(cookieName);

        // override result variant if forced by query parameter
        const paramValue = params.get(queryParamName);
        if (paramValue) {
            resultVariant = group.variants.find((variant) => variant.variantName === paramValue);
        }

        // if not overriden by query prameter, locate variant in cookie
        if (existingVariantName && !resultVariant) {
            resultVariant = group.variants.find((variant) => variant.variantName === existingVariantName);
        }

        // If no variant has been assigned,
        // then randomly choose one based on configured percentage
        if (!resultVariant) {
            const randomNumber = Math.random();
            resultVariant = group.variants.find((variant) => variant.upperBound > randomNumber);
        }

        // If variant if different than the existing cookie,
        // then replace the incoming cookie with the new value.
        if (resultVariant.variantName !== existingVariantName) {
            cookies.delete(cookieName);
            cookies.add(cookieName, resultVariant.variantName);
            request.setHeader('Cookie', cookies.toHeader());
        }

        // If the group was not already included in the incoming query parameter,
        // then add the query parameter to the query string.
        // The query parameter allows the origin to respond with appropriate logic
        // and ensures the A/B group is included in the cache key.
        if (!paramValue) {
            params.append(queryParamName, resultVariant.variantName);
            request.route({
                query: params.toString()
            });
        }

        // Call the requestAction function, if it exists on the variant.
        if (resultVariant.requestAction) {
            resultVariant.requestAction(request);
        }
    });
}

export function onClientResponse(request, response) {
    const cookies = new Cookies(request.getHeader('Cookie'));

    groups.forEach((group) => {
        const cookieName = group.cookieName;
        // Set a response cookie with the A/B group based on
        // the request cookie  set in the onClientRequest handler.
        const cookieValue = cookies.get(cookieName);
        const setCookie = new SetCookie({
            name: cookieName,
            value: cookieValue,
            path: '/'
        });
        response.addHeader('Set-Cookie', setCookie.toHeader());

        // Call the responseAction function, if it exists on the variant.
        const variant = group.variants.find((variant) => variant.variantName == cookieValue);
        if (variant.responseAction) {
            variant.responseAction(request, response);
        }
    });
}

// define country top level domain mapping
const tldMap = {
    CA: '.ca',
    GB: '.co.uk',
    US: '.com'
};

export function onClientRequest(request) {
    // Break out sub domain from host
    const subDomain = request.host.split('.')[0];

    // Break out domain from host
    const domain = request.host.split('.')[1];

    // determine top level domain based on request origin country
    let tld = tldMap[request.userLocation.country];

    // if top level domain is supported default to .com
    if (tld === undefined) {
        tld = '.com';
    }

    // built up new domain
    const redirectDomain = subDomain + '.' + domain + tld;

    // check incoming host different against built up host
    if (request.host !== redirectDomain) {
        // redirect to new host
        request.respondWith(302, {
            Location: [request.scheme + '://' + redirectDomain + request.url]
        }, '');
    }
}