"use strict";
var CloudExperienceHost;
(function (CloudExperienceHost) {
    var UnifiedEnroll;
    (function (UnifiedEnroll) {
        var HTTP_E_STATUS_UNEXPECTED = -2145845247;
        var E_ABORT = -2147483641;
        var S_OK = 0;
        var DMLOGGING_ENROLLMENT = 0;
        var DMLOGGING_WEBAUTH = 1;
        var DMLOGGING_WEBAUTH_HTTP = 2;
        var WEB_AUTHENTICATION_STATUS_USER_CANCEL = 1;
        var WEB_AUTHENTICATION_STATUS_ERROR_HTTP = 2;

        function doAddWorkOrSchoolAccount(userPrincipalName, relatedActivityId) {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                unifiedEnrollmentWorker.doAddWorkOrSchoolAccountAsync(userPrincipalName, relatedActivityId).done(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.doAddWorkOrSchoolAccount = doAddWorkOrSchoolAccount;
        function isAzureActiveDirectoryUser() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                unifiedEnrollmentWorker.isAzureActiveDirectoryUserAsync().done(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.isAzureActiveDirectoryUser = isAzureActiveDirectoryUser;
        function isDeviceCloudJoined() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                unifiedEnrollmentWorker.isDeviceCloudJoinedAsync().done(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.isDeviceCloudJoined = isDeviceCloudJoined;
        function isDeviceADJoined() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                unifiedEnrollmentWorker.isDeviceADJoinedAsync().done(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.isDeviceADJoined = isDeviceADJoined;
        function getNumberOfAccountsFromAad() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                unifiedEnrollmentWorker.getNumberOfAccountsFromAadAsync().done(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.getNumberOfAccountsFromAad = getNumberOfAccountsFromAad;
        function isAdminUser() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var platform = CloudExperienceHost.Environment.getPlatform();
                if ((platform === CloudExperienceHost.TargetPlatform.MOBILE) ||
                    (platform === CloudExperienceHost.TargetPlatform.XBOX) ||
                    (platform === CloudExperienceHost.TargetPlatform.HOLOGRAPHIC)) {
                    
                    completeDispatch(true);
                }
                else {
                    var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                    unifiedEnrollmentWorker.isAdminUserAsync().done(completeDispatch, errorDispatch);
                }
            });
        }
        UnifiedEnroll.isAdminUser = isAdminUser;
        function isManagementRegistrationAllowed() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                unifiedEnrollmentWorker.isManagementRegistrationAllowedAsync().done(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.isManagementRegistrationAllowed = isManagementRegistrationAllowed;
        function isMdmPresent() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                unifiedEnrollmentWorker.isMdmPresentAsync().done(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.isMdmPresent = isMdmPresent;
        function isDomainOperationSupported() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var platform = CloudExperienceHost.Environment.getPlatform();
                if (platform === CloudExperienceHost.TargetPlatform.DESKTOP) {
                    
                    var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                    unifiedEnrollmentWorker.isDomainOperationSupportedAsync().done(completeDispatch, errorDispatch);
                }
                else {
                    completeDispatch(false);
                }
            });
        }
        UnifiedEnroll.isDomainOperationSupported = isDomainOperationSupported;
        function isDomainJoinPending() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                unifiedEnrollmentWorker.isDomainJoinPendingAsync().done(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.isDomainJoinPending = isDomainJoinPending;
        function isDomainLeavePending() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var unifiedEnrollmentWorker = new UnifiedEnrollment.DataModel.UnifiedEnrollmentWorker();
                unifiedEnrollmentWorker.isDomainLeavePendingAsync().done(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.isDomainLeavePending = isDomainLeavePending;
        function doFindDiscovery(UPN, ignoreInsecureRedirect) {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.findDiscoveryServiceAsync(UPN, ignoreInsecureRedirect).then(function (result) {
                    var findDiscoveryServiceObject = {
                        discoveryServiceFullURL: result.discoveryServiceFullURL, isInsecureRedirect: result.discoveryServiceInsecureRedirect
                    };
                    completeDispatch(findDiscoveryServiceObject);
                }, errorDispatch);
            });
        }
        UnifiedEnroll.doFindDiscovery = doFindDiscovery;
        function doDiscoverEndpoints(discoveryUrl, UPN, ignoreInvalidSslCert) {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.discoverEndpointsAsync(discoveryUrl, UPN, ignoreInvalidSslCert).then(function (result) {
                    var discoverEndpointObject = {
                        enrollmentFlags: result.enrollmentFlags, authPolicy: result.authPolicy, policyServiceFullURL: result.policyServiceFullURL,
                        enrollmentServiceFullURL: result.enrollmentServiceFullURL, federatedAuthenticationService: result.federatedAuthenticationService
                    };
                    completeDispatch(discoverEndpointObject);
                }, errorDispatch);
            });
        }
        UnifiedEnroll.doDiscoverEndpoints = doDiscoverEndpoints;
        function doEnrollment(UPN, serverUrl, secret, authPolicy, domainUsername, policyServiceUrl, enrollmentServiceUrl, enrollmentFlags, SID) {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.enrollAsync(UPN, serverUrl, secret, authPolicy, domainUsername, policyServiceUrl, enrollmentServiceUrl, enrollmentFlags, SID).then(function (result) {
                    
                    var enrollmentResultObject = {
                        enrollmentErrorCode: result.enrollmentErrorCode, enrollmentErrorString: result.enrollmentErrorString, enrollmentInternalError: result.enrollmentInternalError
                    };
                    enterpriseManagementWorker.eventWriteForEnrollment(DMLOGGING_ENROLLMENT, result.enrollmentInternalError);
                    completeDispatch(enrollmentResultObject);
                }, function (e) {
                    enterpriseManagementWorker.eventWriteForEnrollment(DMLOGGING_ENROLLMENT, e.number);
                    errorDispatch(e);
                });
            });
        }
        UnifiedEnroll.doEnrollment = doEnrollment;
        function doWebAuth(webAuthUrl) {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var appId = "";
                var platform = CloudExperienceHost.Environment.getPlatform();
                if (platform === CloudExperienceHost.TargetPlatform.MOBILE) {
                    
                    appId = "ms-app://s-1-15-2-4108341168-3731623572-3746702997-906799925-2574769856-1402521575-1149971147";
                } else {
                    
                    appId = "ms-app://windows.immersivecontrolpanel";
                }

                var stopURI = new Windows.Foundation.Uri(appId);
                var startURI = new Windows.Foundation.Uri(webAuthUrl + "&appru=" + Windows.Foundation.Uri.escapeComponent(appId));
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.allowAuthUri(startURI);

                Windows.Security.Authentication.Web.WebAuthenticationBroker.authenticateAsync(Windows.Security.Authentication.Web.WebAuthenticationOptions.useHttpPost | Windows.Security.Authentication.Web.WebAuthenticationOptions.useCorporateNetwork, startURI, stopURI).done(function (result) {
                    enterpriseManagementWorker.removeAuthUriAllowList();
                    var stringToSearch = "wresult=";
                    var beginningIndex = result.responseData.search(stringToSearch);
                    var endingIndex = result.responseData.indexOf("&", beginningIndex + stringToSearch.length);
                    var endString;
                    if (endingIndex === -1) {
                        endString = result.responseData.substring(beginningIndex + stringToSearch.length);
                    } else {
                        endString = result.responseData.substring(beginningIndex + stringToSearch.length, endingIndex);
                    }
                    var webAuthenticationResultObject = {
                        responseStatus: result.responseStatus, responseData: endString
                    };
                    if (WEB_AUTHENTICATION_STATUS_ERROR_HTTP === result.responseStatus) {
                        enterpriseManagementWorker.eventWriteForEnrollment(DMLOGGING_WEBAUTH_HTTP, result.responseErrorDetail);
                    } else if (WEB_AUTHENTICATION_STATUS_USER_CANCEL === result.responseStatus) {
                        enterpriseManagementWorker.eventWriteForEnrollment(DMLOGGING_WEBAUTH, E_ABORT);
                    } else {
                        enterpriseManagementWorker.eventWriteForEnrollment(DMLOGGING_WEBAUTH, S_OK);
                    }
                    completeDispatch(webAuthenticationResultObject);
                }, function (e) {
                    enterpriseManagementWorker.removeAuthUriAllowList();
                    enterpriseManagementWorker.eventWriteForEnrollment(1, e.number);
                    errorDispatch(e);
                });
            });
        }
        UnifiedEnroll.doWebAuth = doWebAuth;
        function localizedStrings() {
            var unifiedEnrollmentResources = {};
            var keyList = ['Title', 'LeadText', 'Description', 'UserPlaceholder', 'ServerUrlPlaceholder', 'FooterHeader', 'DjLink', 'Error_NoUsername', 'Error_UsernameFormat',
                'Error_UsernameLookup', 'Error_DomainLookup', 'Error_Network', 'Error_Generic_Code', 'Error_Generic', 'NextButton', 'Error_MDM_StandardUser', 'Error_MDM_AlreadyConnected',
                'Error_MDM_DiscoveryError', 'DomainUsernamePlaceholder', 'PasswordPlaceholder', 'EnrollerLeadText', 'EnrollmentErrorFinishedTitle',
                'EnrollmentErrorFinishedLeadText', 'EnrollmentFinishedTitle', 'EnrollmentFinishedLeadText', 'FinishedButton', 'InsecureRedirectTitle', 'InsecureRedirectLeadText',
                'InsecureRedirectDescription', 'InvalidCertTitle', 'InvalidCertLeadText', 'InvalidCertDescription', 'TraceIdError', 'WebAuthError', 'MENROLL_E_DEVICE_UNKNOWN_ERROR', 'MENROLL_E_DEVICENOTSUPPORTED',
                'MENROLL_E_CONNECTIVITY', 'MENROLL_E_DEVICECAPREACHED', 'MENROLL_E_DEVICE_AUTHENTICATION_ERROR', 'MENROLL_E_PROV_UNKNOWN', 'MENROLL_E_PLATFORM_UNKNOWN_ERROR', 'DiscoveryProgressText',
                'WABProgressText'];
            keyList.forEach(function (key) {
                var resourceId = '/unifiedEnrollment/' + key;
                unifiedEnrollmentResources[key] = WinJS.Resources.getString(resourceId).value;
            });
            return JSON.stringify(unifiedEnrollmentResources);
        }
        UnifiedEnroll.localizedStrings = localizedStrings;
    })(UnifiedEnroll = CloudExperienceHost.UnifiedEnroll || (CloudExperienceHost.UnifiedEnroll = {}));
})(CloudExperienceHost || (CloudExperienceHost = {}));