"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(module, "exports", {
    enumerable: true,
    get: function() {
        return _default;
    }
});
const _https = _interop_require_default(require("https"));
const _url = require("url");
const _util = require("@middy/util");
const _clients3 = require("@aws-sdk/client-s3");
function _interop_require_default(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
const defaults = {
    AwsClient: _clients3.S3Client,
    awsClientOptions: {},
    awsClientAssumeRole: undefined,
    awsClientCapture: undefined,
    httpsCapture: undefined,
    disablePrefetch: false,
    bodyType: undefined,
    __https: _https.default
};
let https = _https.default;
const s3ObjectResponseMiddleware = (opts = {})=>{
    const options = {
        ...defaults,
        ...opts
    };
    if (![
        'stream',
        'promise'
    ].includes(options.bodyType)) {
        throw new Error('[s3-object-response] bodyType is invalid');
    }
    if (options.httpsCapture) {
        https = options.httpsCapture(options.__https);
    }
    let client;
    if ((0, _util.canPrefetch)(options)) {
        client = (0, _util.createPrefetchClient)(options);
    }
    const s3ObjectResponseMiddlewareBefore = async (request)=>{
        const { inputS3Url, outputRoute, outputToken } = request.event.getObjectContext;
        request.internal.s3ObjectResponse = {
            RequestRoute: outputRoute,
            RequestToken: outputToken
        };
        const parsedInputS3Url = new _url.URL(inputS3Url);
        const fetchOptions = {
            method: 'GET',
            host: parsedInputS3Url.hostname,
            path: parsedInputS3Url.pathname
        };
        request.context.s3Object = fetchType(options.bodyType, fetchOptions);
    };
    const s3ObjectResponseMiddlewareAfter = async (request)=>{
        if (!client) {
            client = await (0, _util.createClient)(options, request);
        }
        request.response.Body ??= request.response.body;
        delete request.response.body;
        await client.send(new _clients3.WriteGetObjectResponseCommand({
            ...request.internal.s3ObjectResponse,
            ...request.response
        }));
        return {
            statusCode: 200
        };
    };
    return {
        before: s3ObjectResponseMiddlewareBefore,
        after: s3ObjectResponseMiddlewareAfter
    };
};
const fetchType = (type, fetchOptions)=>{
    if (type === 'stream') {
        return fetchStream(fetchOptions);
    } else if (type === 'promise') {
        return fetchPromise(fetchOptions);
    }
};
const fetchStream = (fetchOptions)=>{
    return https.request(fetchOptions);
};
const fetchPromise = (fetchOptions)=>{
    return new Promise((resolve, reject)=>{
        let data = '';
        const stream = fetchStream(fetchOptions);
        stream.on('data', (chunk)=>{
            data += chunk;
        });
        stream.on('end', ()=>resolve(data));
        stream.on('error', (error)=>reject(error));
    });
};
const _default = s3ObjectResponseMiddleware;