/**
 * -------------------------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.
 * See License in the project root for license information.
 * -------------------------------------------------------------------------------------------
 */
import { getPathParameters } from "./getPathParameters.js";
import { HttpMethod } from "./httpMethod.js";
import { RequestInformation } from "./requestInformation.js";
const sanitizeMethodName = (methodName) => {
    if (methodName.startsWith("to")) {
        return methodName.substring(2).replace("RequestInformation", "").toLowerCase();
    }
    return methodName;
};
const getRequestMethod = (key) => {
    switch (sanitizeMethodName(key)) {
        case "delete":
            return "delete";
        case "get":
            return "get";
        case "head":
            return "head";
        case "options":
            return "options";
        case "patch":
            return "patch";
        case "post":
            return "post";
        case "put":
            return "put";
        default:
            return undefined;
    }
};
// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
const toRequestInformation = (urlTemplate, pathParameters, metadata, requestAdapter, httpMethod, body, bodyMediaType, requestConfiguration) => {
    const requestInfo = new RequestInformation(httpMethod, urlTemplate, pathParameters);
    requestInfo.configure(requestConfiguration, metadata.queryParametersMapper);
    addAcceptHeaderIfPresent(metadata, requestInfo);
    if (metadata.requestBodySerializer) {
        if (!body)
            throw new Error("body cannot be undefined");
        if (typeof metadata.requestBodySerializer === "function") {
            requestInfo.setContentFromParsable(requestAdapter, metadata.requestBodyContentType ? metadata.requestBodyContentType : bodyMediaType, body, metadata.requestBodySerializer);
        }
        else {
            requestInfo.setContentFromScalar(requestAdapter, metadata.requestBodyContentType ? metadata.requestBodyContentType : bodyMediaType, body);
        }
    }
    else if (metadata.requestInformationContentSetMethod === "setStreamContent") {
        if (!body)
            throw new Error("body cannot be undefined");
        requestInfo.setStreamContent(body, metadata.requestBodyContentType ? metadata.requestBodyContentType : bodyMediaType);
    }
    return requestInfo;
};
const addAcceptHeaderIfPresent = (metadata, requestInfo) => {
    if (metadata.responseBodyContentType) {
        requestInfo.headers.tryAdd("Accept", metadata.responseBodyContentType);
    }
};
const getRequestMediaTypeUserDefinedValue = (requestMetadata, args) => {
    if (args.length > 2 && !requestMetadata.requestBodySerializer && requestMetadata.requestInformationContentSetMethod === "setStreamContent" && typeof args[1] === "string") {
        // request body with unknown media type so we have an argument for it.
        return args[1];
    }
    return undefined;
};
const getRequestConfigurationValue = (args) => {
    if (args.length > 0) {
        // request configuration is always the last argument
        return args[args.length - 1];
    }
    return undefined;
};
const send = (requestAdapter, requestInfo, metadata) => {
    switch (metadata.adapterMethodName) {
        case "send":
            if (!metadata.responseBodyFactory) {
                throw new Error("couldn't find response body factory");
            }
            return requestAdapter.send(requestInfo, metadata.responseBodyFactory, metadata.errorMappings);
        case "sendCollection":
            if (!metadata.responseBodyFactory) {
                throw new Error("couldn't find response body factory");
            }
            return requestAdapter.sendCollection(requestInfo, metadata.responseBodyFactory, metadata.errorMappings);
        case "sendEnum":
            if (!metadata.enumObject) {
                throw new Error("couldn't find response body factory");
            }
            return requestAdapter.sendEnum(requestInfo, metadata.enumObject, metadata.errorMappings);
        case "sendCollectionOfEnum":
            if (!metadata.enumObject) {
                throw new Error("couldn't find response body factory");
            }
            return requestAdapter.sendCollectionOfEnum(requestInfo, metadata.enumObject, metadata.errorMappings);
        case "sendCollectionOfPrimitive":
            if (!metadata.responseBodyFactory) {
                throw new Error("couldn't find response body factory");
            }
            return requestAdapter.sendCollectionOfPrimitive(requestInfo, metadata.responseBodyFactory, metadata.errorMappings);
        case "sendPrimitive":
            if (!metadata.responseBodyFactory) {
                throw new Error("couldn't find response body factory");
            }
            return requestAdapter.sendPrimitive(requestInfo, metadata.responseBodyFactory, metadata.errorMappings);
        case "sendNoResponseContent":
            return requestAdapter.sendNoResponseContent(requestInfo, metadata.errorMappings);
        default:
            throw new Error("couldn't find adapter method");
    }
};
export const apiClientProxifier = (requestAdapter, pathParameters, navigationMetadata, requestsMetadata) => {
    if (!requestAdapter)
        throw new Error("requestAdapter cannot be undefined");
    if (!pathParameters)
        throw new Error("pathParameters cannot be undefined");
    return new Proxy({}, {
        get: (_, property) => {
            const name = String(property);
            if (name === "withUrl") {
                return (rawUrl) => {
                    if (!rawUrl)
                        throw new Error("rawUrl cannot be undefined");
                    return apiClientProxifier(requestAdapter, getPathParameters(rawUrl), navigationMetadata, requestsMetadata);
                };
            }
            if (requestsMetadata) {
                const metadataKey = getRequestMethod(name);
                if (metadataKey) {
                    const metadata = requestsMetadata[metadataKey];
                    if (metadata) {
                        switch (name) {
                            case "get":
                                return (requestConfiguration) => {
                                    const requestInfo = toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.GET, undefined, undefined, requestConfiguration);
                                    return send(requestAdapter, requestInfo, metadata);
                                };
                            case "patch":
                                return (...args) => {
                                    const requestInfo = toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.PATCH, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
                                    return send(requestAdapter, requestInfo, metadata);
                                };
                            case "put":
                                return (...args) => {
                                    const requestInfo = toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.PUT, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
                                    return send(requestAdapter, requestInfo, metadata);
                                };
                            case "delete":
                                return (...args) => {
                                    const requestInfo = toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.DELETE, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
                                    return send(requestAdapter, requestInfo, metadata);
                                };
                            case "post":
                                return (...args) => {
                                    const requestInfo = toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.POST, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
                                    return send(requestAdapter, requestInfo, metadata);
                                };
                            case "toGetRequestInformation":
                                return (requestConfiguration) => {
                                    return toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.GET, undefined, undefined, requestConfiguration);
                                };
                            case "toPatchRequestInformation":
                                return (...args) => {
                                    return toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.PATCH, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
                                };
                            case "toPutRequestInformation":
                                return (...args) => {
                                    return toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.PUT, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
                                };
                            case "toDeleteRequestInformation":
                                return (...args) => {
                                    return toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.DELETE, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
                                };
                            case "toPostRequestInformation":
                                return (...args) => {
                                    return toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.POST, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
                                };
                            default:
                                break;
                        }
                    }
                }
            }
            if (navigationMetadata) {
                const navigationCandidate = navigationMetadata[name];
                if (navigationCandidate) {
                    if (!navigationCandidate.pathParametersMappings || navigationCandidate.pathParametersMappings.length === 0) {
                        // navigation property
                        return apiClientProxifier(requestAdapter, getPathParameters(pathParameters), navigationCandidate.navigationMetadata, navigationCandidate.requestsMetadata);
                    }
                    return (...argArray) => {
                        // navigation method like indexers or multiple path parameters
                        const downWardPathParameters = getPathParameters(pathParameters);
                        if (navigationCandidate.pathParametersMappings && navigationCandidate.pathParametersMappings.length > 0) {
                            for (let i = 0; i < argArray.length; i++) {
                                const element = argArray[i];
                                if (element === undefined || element === null || element === "") {
                                    throw new Error(`path parameter ${navigationCandidate.pathParametersMappings[i]} cannot be undefined`);
                                }
                                else {
                                    downWardPathParameters[navigationCandidate.pathParametersMappings[i]] = element;
                                }
                            }
                        }
                        return apiClientProxifier(requestAdapter, downWardPathParameters, navigationCandidate.navigationMetadata, navigationCandidate.requestsMetadata);
                    };
                }
                throw new Error(`couldn't find navigation property ${name} data: ${JSON.stringify(navigationMetadata)}`);
            }
        },
    });
};
//# sourceMappingURL=apiClientProxifier.js.map