"use strict";
var CloudExperienceHost;
(function (CloudExperienceHost) {
    var Context = (function () {
        function Context() {
        }
        return Context;
    })();
    CloudExperienceHost.Context = Context;
    var Navigator = (function () {
        function Navigator(view, contractHandler) {
            this._listeners = new Object;
            this._view = view;
            this._contractHandler = contractHandler;
            this._view.addEventListener("MSWebViewNavigationCompleted", this._navigationCompleted.bind(this));
        }
        Navigator.prototype._fireEvent = function (errorName, e) {
            var listeners = this._listeners[errorName];
            if (listeners) {
                listeners.map(function (listener) {
                    listener.call(this, e);
                }.bind(this));
            }
        };
        Navigator.prototype._fireErrorEvent = function (e) {
            this._fireEvent("Error", e);
        };
        Navigator.prototype._isServerOffline = function (webErrorStatus) {
            var isServerOffline = false;
            switch (webErrorStatus) {
                case Windows.Web.WebErrorStatus.httpVersionNotSupported:
                case Windows.Web.WebErrorStatus.gone:
                case Windows.Web.WebErrorStatus.notFound:
                case Windows.Web.WebErrorStatus.notImplemented:
                case Windows.Web.WebErrorStatus.requestTimeout:
                case Windows.Web.WebErrorStatus.serverUnreachable:
                case Windows.Web.WebErrorStatus.serviceUnavailable:
                case Windows.Web.WebErrorStatus.timeout:
                    isServerOffline = true;
                    break;
                default:
                    isServerOffline = false;
                    break;
            }
            return isServerOffline;
        };
        Navigator.prototype._navigationCompleted = function (e) {
            if (e.isSuccess === true) {
                CloudExperienceHost.Telemetry.WebAppTelemetry.getInstance().logEvent("NavigationSucceed", JSON.stringify({
                    webErrorStatus: e.webErrorStatus,
                    uri: CloudExperienceHost.UriHelper.RemovePIIFromUri(e.uri)
                }));
                this._fireEvent("NavigationCompleted", this._currentNode);
            }
            else {
                var hasInternetAccess = CloudExperienceHost.Environment.hasInternetAccess();
                var isServerOffline = this._isServerOffline(e.webErrorStatus);
                CloudExperienceHost.Telemetry.WebAppTelemetry.getInstance().logEvent("NavigationFailed", JSON.stringify({
                    webErrorStatus: e.webErrorStatus,
                    uri: CloudExperienceHost.UriHelper.RemovePIIFromUri(e.uri),
                    hasInternetAccess: hasInternetAccess,
                    isServerOffline: isServerOffline
                }));
                if (!hasInternetAccess || isServerOffline) {
                    var offlineID = this._currentNode.offlineID;
                    if (offlineID) {
                        this._currentNode = this._navMesh.getNode(offlineID);
                        if (this._currentNode) {
                            this._navigateToCurrentNode().done();
                            return;
                        }
                    }
                }
                this._fireErrorEvent(new CloudExperienceHost.NavigationError(e.webErrorStatus, e.uri, this._currentNode));
            }
        };
        Navigator.prototype._getEncoding = function () {
            var encoding = Windows.Storage.Streams.UnicodeEncoding.utf8;
            if (this._currentNode.encoding) {
                switch (this._currentNode.encoding.toLowerCase()) {
                    case "utf8":
                        encoding = Windows.Storage.Streams.UnicodeEncoding.utf8;
                        break;
                    case "utf16le":
                        encoding = Windows.Storage.Streams.UnicodeEncoding.utf16LE;
                        break;
                    case "utf16be":
                        encoding = Windows.Storage.Streams.UnicodeEncoding.utf16BE;
                        break;
                    default:
                        encoding = Windows.Storage.Streams.UnicodeEncoding.utf8;
                        break;
                }
            }
            return encoding;
        };
        Navigator.prototype._createHttpRequestMessage = function (httpMethod, url, queryString) {
            var qs = "";
            if (queryString) {
                if (url.indexOf('?') === -1) {
                    qs = '?';
                }
                else {
                    qs = '&';
                }
                qs = qs + queryString;
            }
            var uri = new Windows.Foundation.Uri(url + qs);
            return new Windows.Web.Http.HttpRequestMessage(httpMethod, uri);
        };
        Navigator.prototype._getQueryString = function () {
            return new WinJS.Promise(function (completeDispatch, errorDispatch ) {
                if (this._currentNode.queryStringBuilder) {
                    this._contractHandler.invokeFromString(this._currentNode.url, this._currentNode.queryStringBuilder, null).then(function (result) {
                        completeDispatch(result);
                    }.bind(this), errorDispatch.bind(this));
                }
                else {
                    completeDispatch(null);
                }
            }.bind(this));
        };
        Navigator.prototype._appendCustomHeaders = function (httpRequestMessage) {
            httpRequestMessage.headers.append("hostApp", "CloudExperienceHost");
            httpRequestMessage.headers.append("cxh-hostAppVersion", CloudExperienceHost.getVersion());
            httpRequestMessage.headers.append("cxh-osVersionInfo", JSON.stringify(CloudExperienceHostAPI.Environment.osVersionInfo));
            httpRequestMessage.headers.append("cxh-osPlatform", CloudExperienceHost.Environment.getPlatform());
            httpRequestMessage.headers.append("cxh-preferredLanguage", CloudExperienceHost.Globalization.Language.getPreferredLang());
            httpRequestMessage.headers.append("cxh-isRTL", (CloudExperienceHost.Globalization.Language.getReadingDirection() === "rtl").toString());
            httpRequestMessage.headers.append("cxh-cxid", this._currentNode.cxid);
            
            if (CloudExperienceHost.Environment.getPlatform() === CloudExperienceHost.TargetPlatform.DESKTOP) {
                var themeColors = CloudExperienceHost.Styling.getThemeColors();
                var cxhColors = "";
                Object.keys(themeColors).forEach(function (colorKey) {
                    cxhColors += colorKey + "=" + themeColors[colorKey] + ";";
                });
                httpRequestMessage.headers.append("cxh-colors", cxhColors);
            }
            var context = CloudExperienceHost.getContext();
            for (var key in context) {
                if (context[key]) {
                    httpRequestMessage.headers.append("cxh-" + key, context[key]);
                }
            }
            if (CloudExperienceHost.Telemetry.WebAppTelemetry != null) {
                httpRequestMessage.headers.append("client-request-id", CloudExperienceHost.Telemetry.WebAppTelemetry.getInstance().getId());
                httpRequestMessage.headers.append("cxh-correlationId", CloudExperienceHost.Telemetry.WebAppTelemetry.getInstance().getId());
            }
        };
        Navigator.prototype._addDataToRequest = function (httpRequestMessage, key, value) {
            if (httpRequestMessage.method === Windows.Web.Http.HttpMethod.get) {
                if (!key) {
                    throw new CloudExperienceHost.InvalidArgumentError("key cannot be empty for GET request");
                }
                httpRequestMessage.headers.append(key, value);
            }
            else {
                var content = !!key ? (key + "=" + value) : value;
                var contentType = this._currentNode.contentType || "application/x-www-form-urlencoded";
                httpRequestMessage.content = new Windows.Web.Http.HttpStringContent(content, this._getEncoding(), contentType);
            }
        };
        Navigator.prototype._initializeRequest = function (httpRequestMessage) {
            return new WinJS.Promise(function (completeDispatch, errorDispatch ) {
                this._appendCustomHeaders(httpRequestMessage);
                if (this._currentNode.initialize) {
                    this._contractHandler.invokeFromString(this._currentNode.url, this._currentNode.initialize.getData, null).then(function (result) {
                        this._addDataToRequest(httpRequestMessage, this._currentNode.initialize.key, result);
                        completeDispatch(httpRequestMessage);
                    }.bind(this), errorDispatch.bind(this));
                }
                else {
                    completeDispatch(httpRequestMessage);
                }
            }.bind(this));
        };
        Navigator.prototype._navigateToCurrentNode = function () {
            return new WinJS.Promise(function (completeDispatch, errorDispatch ) {
                
                CloudExperienceHost.Telemetry.WebAppTelemetry.getInstance().start(this._currentNode.cxid);
                this._fireEvent("NavigationStarting", this._currentNode);
                this._nextNode = null;
                this._getQueryString()
                    .then(function (qs) {
                    var httpMethod = ((this._currentNode.httpMethod === 'post') ? Windows.Web.Http.HttpMethod.post : Windows.Web.Http.HttpMethod.get);
                    return this._createHttpRequestMessage(httpMethod, this._currentNode.url, qs);
                }.bind(this), errorDispatch.bind(this))
                    .then(function (httpRequestMessage) {
                    return this._initializeRequest(httpRequestMessage);
                }.bind(this), errorDispatch.bind(this))
                    .then(function (httpRequestMessage) {
                    var allowlist = [
                        'requestUri',
                        'method',
                        'headers',
                        'cxh-osVersionInfo',
                        'platformId',
                        'majorVersion',
                        'minorVersion',
                        'buildNumber',
                        'hostapp',
                        'client-request-id',
                        'cxh-protocol',
                        'cxh-cxid',
                        'cxh-preferredLanguage',
                        'cxh-correlationId',
                        
                        'cxh-osPlatform',
                        'cxh-platform',
                        'cxh-isRTL',
                        'cxh-colors',
                        'cxh-host',
                        'cxh-hostAppVersion'
                    ];
                    CloudExperienceHost.Telemetry.WebAppTelemetry.getInstance().logEvent("NavigationStarted", JSON.stringify({
                        requestUri: httpRequestMessage.requestUri, method: httpRequestMessage.method, headers: httpRequestMessage.headers
                    }, allowlist));
                    this._view.navigateWithHttpRequestMessage(httpRequestMessage);
                    completeDispatch();
                }.bind(this), errorDispatch.bind(this));
            }.bind(this));
        };
        Navigator.prototype._getNext = function (appResult) {
            var node;
            if (this._currentNode) {
                switch (appResult) {
                    case CloudExperienceHost.AppResult.success:
                        node = this._navMesh.getNode(this._currentNode.successID);
                        break;
                    case CloudExperienceHost.AppResult.cancel:
                        node = this._navMesh.getNode(this._currentNode.cancelID);
                        break;
                    case CloudExperienceHost.AppResult.abort:
                        node = this._navMesh.getNode(this._currentNode.abortID);
                        break;
                    case CloudExperienceHost.AppResult.action1:
                        node = this._navMesh.getNode(this._currentNode.action1ID);
                        break;
                    case CloudExperienceHost.AppResult.action2:
                        node = this._navMesh.getNode(this._currentNode.action2ID);
                        break;
                    case CloudExperienceHost.AppResult.action3:
                        node = this._navMesh.getNode(this._currentNode.action3ID);
                        break;
                    default:
                        node = this._navMesh.getNode(this._currentNode.failID);
                        break;
                }
            }
            return node;
        };
        Navigator.prototype.addEventListener = function (type, listener) {
            if (!this._listeners.hasOwnProperty(type)) {
                this._listeners[type] = new Array();
            }
            this._listeners[type].push(listener);
        };
        Navigator.prototype.navigate = function (navMesh, cxid) {
            this._navMesh = navMesh;
            if (cxid) {
                this._currentNode = this._navMesh.getNode(cxid);
            }
            else {
                this._currentNode = this._navMesh.getStart();
            }
            return this._navigateToCurrentNode();
        };
        Navigator.prototype.redirect = function (e) {
            var httpMethod = (e.httpMethod.toUpperCase() === "POST") ? Windows.Web.Http.HttpMethod.post : Windows.Web.Http.HttpMethod.get;
            var httpRequestMessage = this._createHttpRequestMessage(httpMethod, e.url, null);
            this._appendCustomHeaders(httpRequestMessage);
            if (e.value) {
                this._addDataToRequest(httpRequestMessage, e.key, e.value);
            }
            this._view.navigateWithHttpRequestMessage(httpRequestMessage);
        };
        Navigator.prototype.goBack = function () {
            if (this._currentNode) {
                var backNode = this._navMesh.getNode(this._currentNode.backID);
                if (backNode) {
                    
                    CloudExperienceHost.Telemetry.WebAppTelemetry.getInstance().stop(CloudExperienceHost.AppResult.cancel);
                    this._currentNode = backNode;
                }
                this._navigateToCurrentNode().done();
            }
        };
        Navigator.prototype.goNext = function () {
            this._currentNode = this._nextNode;
            if (this._currentNode) {
                this._navigateToCurrentNode().done();
            }
        };
        Navigator.prototype.loadIdentityProvider = function (signInIdentityProvider) {
            var id;
            switch (signInIdentityProvider) {
                case CloudExperienceHost.SignInIdentityProviders.Local:
                    id = 'LOCAL';
                    break;
                case CloudExperienceHost.SignInIdentityProviders.MSA:
                    id = 'MSA';
                    break;
                case CloudExperienceHost.SignInIdentityProviders.AAD:
                    id = 'AAD';
                    break;
                default:
                    throw new CloudExperienceHost.InvalidArgumentError(signInIdentityProvider);
                    break;
            }
            var provider = this._navMesh.getNode(id);
            if (provider) {
                
                CloudExperienceHost.Telemetry.WebAppTelemetry.getInstance().stop(CloudExperienceHost.AppResult.abort);
                this._currentNode = provider;
                this._navigateToCurrentNode().done();
            }
            else {
                throw new CloudExperienceHost.NodeNotFoundError(signInIdentityProvider);
            }
        };
        Navigator.prototype.getNavMesh = function () {
            return this._navMesh;
        };
        Navigator.prototype.webAppDone = function (appResult) {
            
            CloudExperienceHost.Telemetry.WebAppTelemetry.getInstance().stop(appResult);
            this._nextNode = this._getNext(appResult);
            return (this._nextNode ? true : false);
        };
        return Navigator;
    })();
    CloudExperienceHost.Navigator = Navigator;
})(CloudExperienceHost || (CloudExperienceHost = {}));