const isSSG = !!getStaticProps;
const pageIsDynamic = isDynamicRoute(pathname);
if (isSSG && !isFallback) {
    let data: UnwrapPromise<ReturnType<GetStaticProps>>;
    try {
        data = await getStaticProps!({
            ...(pageIsDynamic ? { params: query as ParsedUrlQuery } : undefined),
            ...(isPreview ? { preview: true, previewData: previewData } : undefined),
            locales: renderOpts.locales,
            locale: renderOpts.locale,
            defaultLocale: renderOpts.defaultLocale
        });
    } catch (staticPropsError: any) {
        // ....
    }
    // ...
}

const invalidKeys = Object.keys(data).filter(
    key => key !== 'revalidate' && key !== 'props' && key !== 'redirect' && key !== 'notFound'
);
if (invalidKeys.includes('unstable_revalidate')) {
    throw new Error(UNSTABLE_REVALIDATE_RENAME_ERROR);
}
if (invalidKeys.length) {
    throw new Error(invalidKeysMsg('getStaticProps', invalidKeys));
}

if ('notFound' in data && data.notFound) {
    if (pathname === '/404') {
        throw new Error(`The /404 page can not return notFound in "getStaticProps", please remove it to continue!`);
    }
    (renderOpts as any).isNotFound = true;
}
if ('redirect' in data && data.redirect && typeof data.redirect === 'object') {
    checkRedirectValues(data.redirect as Redirect, req, 'getStaticProps');
    if (isBuildTimeSSG) {
        throw new Error(
            `\`redirect\` can not be returned from getStaticProps during prerendering (${req.url})\n` +
                `See more info here: https://nextjs.org/docs/messages/gsp-redirect-during-prerender`
        );
    }
    (data as any).props = {
        __N_REDIRECT: data.redirect.destination,
        __N_REDIRECT_STATUS: getRedirectStatus(data.redirect)
    };
    if (typeof data.redirect.basePath !== 'undefined') {
        (data as any).props.__N_REDIRECT_BASE_PATH = data.redirect.basePath;
    }
    (renderOpts as any).isRedirect = true;
}

props.pageProps = Object.assign({}, props.pageProps, 'props' in data ? data.props : undefined);

if (getStaticPaths) {
    staticPathsResult = await getStaticPaths({ locales, defaultLocale });
}
if (!staticPathsResult || typeof staticPathsResult !== 'object' || Array.isArray(staticPathsResult)) {
    throw new Error(
        `Invalid value returned from getStaticPaths in ${page}. Received ${typeof staticPathsResult} ${expectedReturnVal}`
    );
}
const invalidStaticPathKeys = Object.keys(staticPathsResult).filter(key => !(key === 'paths' || key === 'fallback'));
if (invalidStaticPathKeys.length > 0) {
    throw new Error(
        `Extra keys returned from getStaticPaths in ${page} (${invalidStaticPathKeys.join(', ')}) ${expectedReturnVal}`
    );
}
if (!(typeof staticPathsResult.fallback === 'boolean' || staticPathsResult.fallback === 'blocking')) {
    throw new Error(`The \`fallback\` key must be returned from getStaticPaths in ${page}.\n` + expectedReturnVal);
}
const toPrerender = staticPathsResult.paths;
if (!Array.isArray(toPrerender)) {
    throw new Error(
        `Invalid \`paths\` value returned from getStaticPaths in ${page}.\n` +
            `\`paths\` must be an array of strings or objects of shape { params: [key: string]: string }`
    );
}

toPrerender.forEach(entry => {
    if (typeof entry === 'string') {
        entry = removeTrailingSlash(entry);
        const localePathResult = normalizeLocalePath(entry, locales);
        let cleanedEntry = entry;
        if (localePathResult.detectedLocale) {
            cleanedEntry = entry.slice(localePathResult.detectedLocale.length + 1);
        } else if (defaultLocale) {
            entry = `/${defaultLocale}${entry}`;
        }
        const result = _routeMatcher(cleanedEntry);
        if (!result) {
            throw new Error(`The provided path \`${cleanedEntry}\` does not match the page: \`${page}\`.`);
        }
        // If leveraging the string paths variant the entry should already be
        // encoded so we decode the segments ensuring we only escape path
        // delimiters
        prerenderPaths.add(
            entry
                .split('/')
                .map(segment => escapePathDelimiters(decodeURIComponent(segment), true))
                .join('/')
        );
        encodedPrerenderPaths.add(entry);
    } else {
        // ...
    }
});

const _validParamKeys = Object.keys(_routeMatcher(page));
if (typeof entry === 'string') {
    // ...
} else {
    const invalidKeys = Object.keys(entry).filter(key => key !== 'params' && key !== 'locale');
    if (invalidKeys.length) {
        throw new Error('...');
    }
    const { params = {} } = entry;
    let builtPage = page;
    let encodedBuiltPage = page;
    _validParamKeys.forEach(validParamKey => {
        const { repeat, optional } = _routeRegex.groups[validParamKey];
        let paramValue = params[validParamKey];
        if (
            optional &&
            params.hasOwnProperty(validParamKey) &&
            (paramValue === null || paramValue === undefined || (paramValue as any) === false)
        ) {
            paramValue = [];
        }
        if ((repeat && !Array.isArray(paramValue)) || (!repeat && typeof paramValue !== 'string')) {
            throw new Error('...');
        }
        let replaced = `[${repeat ? '...' : ''}${validParamKey}]`;
        if (optional) {
            replaced = `[${replaced}]`;
        }
        builtPage = builtPage
            .replace(
                replaced,
                repeat
                    ? (paramValue as string[]).map(segment => escapePathDelimiters(segment, true)).join('/')
                    : escapePathDelimiters(paramValue as string, true)
            )
            .replace(/(?!^)\/$/, '');
        encodedBuiltPage = encodedBuiltPage
            .replace(
                replaced,
                repeat
                    ? (paramValue as string[]).map(encodeURIComponent).join('/')
                    : encodeURIComponent(paramValue as string)
            )
            .replace(/(?!^)\/$/, '');
    });
    if (entry.locale && !locales?.includes(entry.locale)) {
        throw new Error('...');
    }
    const curLocale = entry.locale || defaultLocale || '';
    prerenderPaths.add(`${curLocale ? `/${curLocale}` : ''}${curLocale && builtPage === '/' ? '' : builtPage}`);
    encodedPrerenderPaths.add(
        `${curLocale ? `/${curLocale}` : ''}${curLocale && encodedBuiltPage === '/' ? '' : encodedBuiltPage}`
    );
}

return {
    paths: [...prerenderPaths],
    fallback: staticPathsResult.fallback,
    encodedPaths: [...encodedPrerenderPaths]
};