"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const cookie_1 = require("../../utils/cookie");
const incoming_message_like_1 = __importDefault(require("../incoming-message-like"));
const charset_1 = __importDefault(require("../../processing/encoding/charset"));
const urlUtils = __importStar(require("../../utils/url"));
const contentTypeUtils = __importStar(require("../../utils/content-type"));
const generate_unique_id_1 = __importDefault(require("../../utils/generate-unique-id"));
const same_origin_policy_1 = require("../same-origin-policy");
const headerTransforms = __importStar(require("../header-transforms"));
const service_routes_1 = __importDefault(require("../../proxy/service-routes"));
const builtin_header_names_1 = __importDefault(require("../builtin-header-names"));
const logger_1 = __importDefault(require("../../utils/logger"));
const create_special_page_response_1 = __importDefault(require("../create-special-page-response"));
const http_1 = require("../../utils/http");
const requestCache = __importStar(require("../cache"));
const base_1 = __importDefault(require("./base"));
const factory_1 = __importDefault(require("../request-hooks/events/factory"));
const stream_1 = require("stream");
const promisify_stream_1 = __importDefault(require("../../utils/promisify-stream"));
const buffer_1 = require("../../utils/buffer");
const is_redirect_status_code_1 = __importDefault(require("../../utils/is-redirect-status-code"));
const CANNOT_BE_USED_WITH_WEB_SOCKET_ERR_MSG = 'The function cannot be used with a WebSocket request.';
class RequestPipelineContext extends base_1.default {
    constructor(req, res, serverInfo, proxyless) {
        super((0, generate_unique_id_1.default)());
        this.req = req;
        this.res = res;
        this.serverInfo = serverInfo;
        this.proxyless = proxyless;
        this.isDestResReadableEnded = false;
        this.isAjax = false;
        this.isPage = false;
        this.isHTMLPage = false;
        this.isHtmlImport = false;
        this.isWebSocket = false;
        this.isIframe = false;
        this.isSpecialPage = false;
        this.isWebSocketConnectionReset = false;
        this.goToNextStage = true;
        this.isSameOriginPolicyFailed = false;
        this._initParsedClientSyncCookie();
        this.eventFactory = new factory_1.default(this);
    }
    _initParsedClientSyncCookie() {
        if (!this.req.headers.cookie)
            return;
        const parsedClientSyncCookieStr = (0, cookie_1.parseClientSyncCookieStr)(this.req.headers.cookie);
        if (parsedClientSyncCookieStr)
            this.parsedClientSyncCookie = parsedClientSyncCookieStr;
    }
    // TODO: Rewrite parseProxyUrl instead.
    static _flattenParsedProxyUrl(parsed) {
        if (!parsed)
            return null;
        const parsedResourceType = urlUtils.parseResourceType(parsed.resourceType);
        const dest = {
            url: parsed.destUrl,
            protocol: parsed.destResourceInfo.protocol || '',
            host: parsed.destResourceInfo.host || '',
            hostname: parsed.destResourceInfo.hostname || '',
            port: parsed.destResourceInfo.port || '',
            partAfterHost: parsed.destResourceInfo.partAfterHost || '',
            auth: parsed.destResourceInfo.auth,
            isIframe: !!parsedResourceType.isIframe,
            isForm: !!parsedResourceType.isForm,
            isScript: !!(parsedResourceType.isScript || parsedResourceType.isServiceWorker),
            isEventSource: !!parsedResourceType.isEventSource,
            isHtmlImport: !!parsedResourceType.isHtmlImport,
            isWebSocket: !!parsedResourceType.isWebSocket,
            isServiceWorker: !!parsedResourceType.isServiceWorker,
            isAjax: !!parsedResourceType.isAjax,
            isObject: !!parsedResourceType.isObject,
            charset: parsed.charset || '',
            reqOrigin: parsed.reqOrigin || '',
            credentials: parsed.credentials,
        };
        return { dest, sessionId: parsed.sessionId, windowId: parsed.windowId };
    }
    _isFileDownload() {
        const contentDisposition = this.destRes.headers[builtin_header_names_1.default.contentDisposition];
        return !!contentDisposition &&
            contentDisposition.includes('attachment') &&
            contentDisposition.includes('filename');
    }
    _resolveInjectableUrls(injectableUrls) {
        return injectableUrls.map(url => this.resolveInjectableUrl(url));
    }
    _initRequestNatureInfo() {
        const acceptHeader = this.req.headers[builtin_header_names_1.default.accept];
        this.isWebSocket = this.dest.isWebSocket;
        this.isHtmlImport = this.dest.isHtmlImport;
        this.isAjax = this.dest.isAjax;
        this.isPage = !this.isAjax && !this.isWebSocket && acceptHeader &&
            contentTypeUtils.isPage(acceptHeader) || this.isHtmlImport;
        this.isIframe = this.dest.isIframe;
        this.isSpecialPage = urlUtils.isSpecialPage(this.dest.url);
        this.isFileProtocol = this.dest.protocol === 'file:';
        this.isHTMLPage = this.isPage && !this.isIframe && !this.isHtmlImport;
    }
    _getDestFromReferer(parsedReferer) {
        const dest = parsedReferer.dest;
        dest.partAfterHost = this.req.url || '';
        dest.url = urlUtils.formatUrl(dest);
        return { dest, sessionId: parsedReferer.sessionId, windowId: parsedReferer.windowId };
    }
    _addTemporaryEntryToCache() {
        if (!this.temporaryCacheEntry)
            return;
        this.temporaryCacheEntry.value.res.setBody(this.destResBody);
        requestCache.add(this.temporaryCacheEntry);
        this.temporaryCacheEntry = void 0;
    }
    // API
    dispatch(openSessions) {
        const parsedReqUrl = urlUtils.parseProxyUrl(this.req.url || '');
        const referer = this.req.headers[builtin_header_names_1.default.referer];
        let parsedReferer = referer && urlUtils.parseProxyUrl(referer) || null;
        // TODO: Remove it after parseProxyURL is rewritten.
        let flattenParsedReqUrl = RequestPipelineContext._flattenParsedProxyUrl(parsedReqUrl);
        let flattenParsedReferer = RequestPipelineContext._flattenParsedProxyUrl(parsedReferer);
        // NOTE: Remove that after implementing the https://github.com/DevExpress/testcafe-hammerhead/issues/2155
        if (!flattenParsedReqUrl && flattenParsedReferer)
            flattenParsedReqUrl = this._getDestFromReferer(flattenParsedReferer);
        if (!flattenParsedReqUrl)
            return false;
        const session = openSessions.get(flattenParsedReqUrl.sessionId);
        if (session)
            this.session = session;
        if (!this.session)
            return false;
        if (!flattenParsedReferer && this.session.options.referer) {
            parsedReferer = urlUtils.parseProxyUrl(this.session.options.referer) || null;
            flattenParsedReferer = RequestPipelineContext._flattenParsedProxyUrl(parsedReferer);
        }
        this.dest = flattenParsedReqUrl.dest;
        this.windowId = flattenParsedReqUrl.windowId;
        this.dest.partAfterHost = RequestPipelineContext._preparePartAfterHost(this.dest.partAfterHost);
        this.dest.domain = urlUtils.getDomain(this.dest);
        if (flattenParsedReferer) {
            this.dest.referer = flattenParsedReferer.dest.url;
            this.dest.reqOrigin = this.dest.reqOrigin || urlUtils.getDomain(flattenParsedReferer.dest);
        }
        else
            this.dest.reqOrigin = this.dest.reqOrigin || this.dest.domain;
        this._initRequestNatureInfo();
        this._applyClientSyncCookie();
        return true;
    }
    _applyClientSyncCookie() {
        if (!this.parsedClientSyncCookie)
            return;
        const clientCookie = this.parsedClientSyncCookie.actual.filter(syncCookie => syncCookie.isClientSync && syncCookie.sid === this.session.id);
        this.session.cookies.setByClient(clientCookie);
    }
    static _preparePartAfterHost(str) {
        // Browsers add a leading slash to the pathname part of url (GH-608)
        // For example: url http://www.example.com?gd=GID12082014 will be converted
        // to http://www.example.com/?gd=GID12082014
        return (str[0] === '/' ? '' : '/') + str;
    }
    buildContentInfo() {
        const contentType = this.destRes.headers[builtin_header_names_1.default.contentType] || '';
        const accept = this.req.headers[builtin_header_names_1.default.accept] || '';
        const encoding = (this.destRes.headers[builtin_header_names_1.default.contentEncoding] || '').toLowerCase();
        const isTextPage = this.isPage && contentTypeUtils.isTextPage(contentType);
        if (this.isPage && contentType && !isTextPage)
            this.isPage = !this.isAjax && contentTypeUtils.isPage(contentType);
        const isCSS = contentTypeUtils.isCSSResource(contentType, accept);
        const isManifest = contentTypeUtils.isManifest(contentType);
        const isScript = this.dest.isScript || contentTypeUtils.isScriptResource(contentType, accept);
        const isForm = this.dest.isForm;
        const isObject = this.dest.isObject;
        const isFormWithEmptyResponse = isForm && this.destRes.statusCode === 204;
        const isRedirect = this.destRes.headers[builtin_header_names_1.default.location] &&
            this.destRes.statusCode &&
            (0, is_redirect_status_code_1.default)(this.destRes.statusCode) ||
            false;
        const requireAssetsProcessing = (isCSS || isScript || isManifest) && this.destRes.statusCode !== 204;
        const isNotModified = this.req.method === 'GET' && this.destRes.statusCode === 304 &&
            !!(this.req.headers[builtin_header_names_1.default.ifModifiedSince] ||
                this.req.headers[builtin_header_names_1.default.ifNoneMatch]);
        const requireProcessing = !this.isAjax && !isFormWithEmptyResponse && !isRedirect &&
            !isNotModified && (this.isPage || this.isIframe || requireAssetsProcessing);
        const isFileDownload = this._isFileDownload() && !this.dest.isScript;
        const isIframeWithImageSrc = this.isIframe && !this.isPage && /^\s*image\//.test(contentType);
        const isAttachment = !this.isPage && !this.isAjax && !this.isWebSocket && !this.isIframe &&
            !isTextPage && !isManifest && !isScript && !isForm && !isObject;
        const charset = new charset_1.default();
        const contentTypeUrlToken = urlUtils.getResourceTypeString({
            isIframe: this.isIframe,
            isAjax: this.isAjax,
            isForm, isScript,
        }) || '';
        // NOTE: We need charset information if we are going to process the resource.
        if (requireProcessing && !charset.fromContentType(contentType))
            charset.fromUrl(this.dest.charset);
        if (isFileDownload)
            this.session.handleFileDownload();
        if (isAttachment)
            this._handleAttachment();
        this.contentInfo = {
            charset,
            requireProcessing,
            isIframeWithImageSrc,
            isCSS,
            isScript,
            isManifest,
            isObject,
            encoding,
            contentTypeUrlToken,
            isFileDownload,
            isNotModified,
            isRedirect,
            isAttachment,
            isTextPage,
        };
        logger_1.default.proxy.onContentInfoBuilt(this);
    }
    _handleAttachment() {
        let isOpenedInNewWindow = false;
        if (this.req.url) {
            const url1 = urlUtils.parseProxyUrl(this.req.url);
            const url2 = urlUtils.parseProxyUrl(this.req.headers[builtin_header_names_1.default.referer]);
            isOpenedInNewWindow = (url1 === null || url1 === void 0 ? void 0 : url1.windowId) !== (url2 === null || url2 === void 0 ? void 0 : url2.windowId);
        }
        this.session.handleAttachment({ isOpenedInNewWindow });
    }
    async _getDestResBody(res) {
        if (incoming_message_like_1.default.isIncomingMessageLike(res)) {
            const body = res.getBody();
            if (body)
                return body;
        }
        return (0, http_1.fetchBody)(this.destRes, this.destRes.headers[builtin_header_names_1.default.contentLength]);
    }
    calculateIsDestResReadableEnded() {
        if (!this.contentInfo.isNotModified &&
            !this.contentInfo.isRedirect &&
            !incoming_message_like_1.default.isIncomingMessageLike(this.destRes)) {
            this.destRes.once('end', () => {
                this.isDestResReadableEnded = true;
            });
        }
        else
            this.isDestResReadableEnded = true;
    }
    getInjectableScripts() {
        const taskScript = this.isIframe ? service_routes_1.default.iframeTask : service_routes_1.default.task;
        const scripts = this.session.injectable.scripts.concat(taskScript, this.injectableUserScripts);
        return this._resolveInjectableUrls(scripts);
    }
    getInjectableStyles() {
        return this._resolveInjectableUrls(this.session.injectable.styles);
    }
    redirect(url) {
        if (this.isWebSocket)
            throw new Error(CANNOT_BE_USED_WITH_WEB_SOCKET_ERR_MSG);
        const res = this.res;
        res.statusCode = 302;
        res.setHeader(builtin_header_names_1.default.location, url);
        res.end();
    }
    saveNonProcessedDestResBody(value) {
        this.nonProcessedDestResBody = value;
    }
    closeWithError(statusCode, resBody = '') {
        if ('setHeader' in this.res && !this.res.headersSent) {
            this.res.statusCode = statusCode;
            this.res.setHeader(builtin_header_names_1.default.contentType, 'text/html');
            this.res.write(resBody);
        }
        this.res.end();
        this.goToNextStage = false;
    }
    toProxyUrl(url, isCrossDomain, resourceType, charset, reqOrigin, credentials) {
        const proxyHostname = this.serverInfo.hostname;
        const proxyProtocol = this.serverInfo.protocol;
        const proxyPort = isCrossDomain ? this.serverInfo.crossDomainPort.toString() : this.serverInfo.port.toString();
        const sessionId = this.session.id;
        const windowId = this.windowId;
        if (isCrossDomain)
            reqOrigin = this.dest.domain;
        return urlUtils.getProxyUrl(url, {
            proxyHostname,
            proxyProtocol,
            proxyPort,
            sessionId,
            resourceType,
            charset,
            windowId,
            reqOrigin,
            credentials,
        });
    }
    getProxyOrigin(isCrossDomain = false) {
        return urlUtils.getDomain({
            protocol: this.serverInfo.protocol,
            hostname: this.serverInfo.hostname,
            port: isCrossDomain ? this.serverInfo.crossDomainPort : this.serverInfo.port,
        });
    }
    isPassSameOriginPolicy() {
        const shouldPerformCORSCheck = this.isAjax && !this.contentInfo.isNotModified;
        return !shouldPerformCORSCheck || (0, same_origin_policy_1.check)(this);
    }
    sendResponseHeaders() {
        if (this.isWebSocket)
            throw new Error(CANNOT_BE_USED_WITH_WEB_SOCKET_ERR_MSG);
        const headers = headerTransforms.forResponse(this);
        const res = this.res;
        if (this.isHTMLPage && this.session.options.disablePageCaching)
            headerTransforms.setupPreventCachingHeaders(headers);
        logger_1.default.proxy.onResponse(this, headers);
        res.writeHead(this.destRes.statusCode, headers);
        res.addTrailers(this.destRes.trailers);
    }
    async mockResponse(eventProvider) {
        logger_1.default.destination.onMockedRequest(this);
        this.destRes = await this.getMockResponse();
        this.buildContentInfo();
        if (!this.mock.hasError)
            return;
        await this.handleMockError(eventProvider);
        logger_1.default.proxy.onMockResponseError(this.requestFilterRules[0], this.mock.error);
    }
    resolveInjectableUrl(url) {
        return this.serverInfo.domain + url;
    }
    respondForSpecialPage() {
        this.destRes = (0, create_special_page_response_1.default)();
        this.buildContentInfo();
    }
    async fetchDestResBody() {
        this.destResBody = await this._getDestResBody(this.destRes);
        if (!this.temporaryCacheEntry)
            return;
        this._addTemporaryEntryToCache();
    }
    async pipeNonProcessedResponse() {
        if (!this.serverInfo.cacheRequests) {
            this.destRes.pipe(this.res);
            return;
        }
        this.destResBody = await this._getDestResBody(this.destRes);
        if (this.temporaryCacheEntry && this.destResBody.length < requestCache.MAX_SIZE_FOR_NON_PROCESSED_RESOURCE)
            this._addTemporaryEntryToCache();
        this.res.write(this.destResBody);
        this.res.end();
    }
    createCacheEntry(res) {
        if (requestCache.shouldCache(this) && !incoming_message_like_1.default.isIncomingMessageLike(res))
            this.temporaryCacheEntry = requestCache.create(this.reqOpts, res);
    }
    async callOnResponseEventCallbackWithoutBodyForNonProcessedResource(ctx, onResponseEventDataWithoutBody) {
        await Promise.all(onResponseEventDataWithoutBody.map(async (eventData) => {
            await ctx.onRequestHookResponse(ctx.session.requestHookEventProvider, ctx.eventFactory, eventData.rule, eventData.opts);
        }));
        ctx.destRes.pipe(ctx.res);
    }
    async callOnResponseEventCallbackForMotModifiedResource(ctx) {
        await Promise.all(ctx.onResponseEventData.map(async (eventData) => {
            await ctx.onRequestHookResponse(ctx.session.requestHookEventProvider, ctx.eventFactory, eventData.rule, eventData.opts);
        }));
        ctx.res.end();
    }
    async callOnResponseEventCallbackWithBodyForNonProcessedRequest(ctx, onResponseEventDataWithBody) {
        const destResBodyCollectorStream = new stream_1.PassThrough();
        ctx.destRes.pipe(destResBodyCollectorStream);
        (0, promisify_stream_1.default)(destResBodyCollectorStream).then(async (data) => {
            ctx.saveNonProcessedDestResBody(data);
            await Promise.all(onResponseEventDataWithBody.map(async (eventData) => {
                await ctx.onRequestHookResponse(ctx.session.requestHookEventProvider, ctx.eventFactory, eventData.rule, eventData.opts);
            }));
            (0, buffer_1.toReadableStream)(data).pipe(ctx.res);
        });
    }
}
exports.default = RequestPipelineContext;module.exports = exports.default;