/* @internal */
namespace ts {
    const base64UrlRegExp = /^data:(?:application\/json(?:;charset=[uU][tT][fF]-8);base64,([A-Za-z0-9+\/=]+)$)?/;

    export interface SourceMapper {
        toLineColumnOffset(fileName: string, position: number): LineAndCharacter;
        tryGetSourcePosition(info: DocumentPosition): DocumentPosition | undefined;
        tryGetGeneratedPosition(info: DocumentPosition): DocumentPosition | undefined;
        clearCache(): void;
    }

    export interface SourceMapperHost {
        useCaseSensitiveFileNames(): boolean;
        getCurrentDirectory(): string;
        getProgram(): Program | undefined;
        fileExists?(path: string): boolean;
        readFile?(path: string, encoding?: string): string | undefined;
        getSourceFileLike?(fileName: string): SourceFileLike | undefined;
        getDocumentPositionMapper?(generatedFileName: string, sourceFileName?: string): DocumentPositionMapper | undefined;
        log(s: string): void;
    }

    export function getSourceMapper(host: SourceMapperHost): SourceMapper {
        const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
        const currentDirectory = host.getCurrentDirectory();
        const sourceFileLike = new Map<string, SourceFileLike | false>();
        const documentPositionMappers = new Map<string, DocumentPositionMapper>();
        return { tryGetSourcePosition, tryGetGeneratedPosition, toLineColumnOffset, clearCache };

        function toPath(fileName: string) {
            return ts.toPath(fileName, currentDirectory, getCanonicalFileName);
        }

        function getDocumentPositionMapper(generatedFileName: string, sourceFileName?: string) {
            const path = toPath(generatedFileName);
            const value = documentPositionMappers.get(path);
            if (value) return value;

            let mapper: DocumentPositionMapper | undefined;
            if (host.getDocumentPositionMapper) {
                mapper = host.getDocumentPositionMapper(generatedFileName, sourceFileName);
            }
            else if (host.readFile) {
                const file = getSourceFileLike(generatedFileName);
                mapper = file && ts.getDocumentPositionMapper(
                    { getSourceFileLike, getCanonicalFileName, log: s => host.log(s) },
                    generatedFileName,
                    getLineInfo(file.text, getLineStarts(file)),
                    f => !host.fileExists || host.fileExists(f) ? host.readFile!(f) : undefined
                );
            }
            documentPositionMappers.set(path, mapper || identitySourceMapConsumer);
            return mapper || identitySourceMapConsumer;
        }

        function tryGetSourcePosition(info: DocumentPosition): DocumentPosition | undefined {
            if (!isDeclarationFileName(info.fileName)) return undefined;

            const file = getSourceFile(info.fileName);
            if (!file) return undefined;

            const newLoc = getDocumentPositionMapper(info.fileName).getSourcePosition(info);
            return !newLoc || newLoc === info ? undefined : tryGetSourcePosition(newLoc) || newLoc;
        }

        function tryGetGeneratedPosition(info: DocumentPosition): DocumentPosition | undefined {
            if (isDeclarationFileName(info.fileName)) return undefined;

            const sourceFile = getSourceFile(info.fileName);
            if (!sourceFile) return undefined;

            const program = host.getProgram()!;
            // If this is source file of project reference source (instead of redirect) there is no generated position
            if (program.isSourceOfProjectReferenceRedirect(sourceFile.fileName)) {
                return undefined;
            }

            const options = program.getCompilerOptions();
            const outPath = outFile(options);

            const declarationPath = outPath ?
                removeFileExtension(outPath) + Extension.Dts :
                getDeclarationEmitOutputFilePathWorker(info.fileName, program.getCompilerOptions(), currentDirectory, program.getCommonSourceDirectory(), getCanonicalFileName);
            if (declarationPath === undefined) return undefined;

            const newLoc = getDocumentPositionMapper(declarationPath, info.fileName).getGeneratedPosition(info);
            return newLoc === info ? undefined : newLoc;
        }

        function getSourceFile(fileName: string) {
            const program = host.getProgram();
            if (!program) return undefined;

            const path = toPath(fileName);
            // file returned here could be .d.ts when asked for .ts file if projectReferences and module resolution created this source file
            const file = program.getSourceFileByPath(path);
            return file && file.resolvedPath === path ? file : undefined;
        }

        function getOrCreateSourceFileLike(fileName: string): SourceFileLike | undefined {
            const path = toPath(fileName);
            const fileFromCache = sourceFileLike.get(path);
            if (fileFromCache !== undefined) return fileFromCache ? fileFromCache : undefined;

            if (!host.readFile || host.fileExists && !host.fileExists(path)) {
                sourceFileLike.set(path, false);
                return undefined;
            }

            // And failing that, check the disk
            const text = host.readFile(path);
            const file = text ? createSourceFileLike(text) : false;
            sourceFileLike.set(path, file);
            return file ? file : undefined;
        }

        // This can be called from source mapper in either source program or program that includes generated file
        function getSourceFileLike(fileName: string) {
            return !host.getSourceFileLike ?
                getSourceFile(fileName) || getOrCreateSourceFileLike(fileName) :
                host.getSourceFileLike(fileName);
        }

        function toLineColumnOffset(fileName: string, position: number): LineAndCharacter {
            const file = getSourceFileLike(fileName)!; // TODO: GH#18217
            return file.getLineAndCharacterOfPosition(position);
        }

        function clearCache(): void {
            sourceFileLike.clear();
            documentPositionMappers.clear();
        }
    }

    /**
     * string | undefined to contents of map file to create DocumentPositionMapper from it
     * DocumentPositionMapper | false to give back cached DocumentPositionMapper
     */
    export type ReadMapFile = (mapFileName: string, mapFileNameFromDts: string | undefined) => string | undefined | DocumentPositionMapper | false;

    export function getDocumentPositionMapper(
        host: DocumentPositionMapperHost,
        generatedFileName: string,
        generatedFileLineInfo: LineInfo,
        readMapFile: ReadMapFile) {
        let mapFileName = tryGetSourceMappingURL(generatedFileLineInfo);
        if (mapFileName) {
            const match = base64UrlRegExp.exec(mapFileName);
            if (match) {
                if (match[1]) {
                    const base64Object = match[1];
                    return convertDocumentToSourceMapper(host, base64decode(sys, base64Object), generatedFileName);
                }
                // Not a data URL we can parse, skip it
                mapFileName = undefined;
            }
        }
        const possibleMapLocations: string[] = [];
        if (mapFileName) {
            possibleMapLocations.push(mapFileName);
        }
        possibleMapLocations.push(generatedFileName + ".map");
        const originalMapFileName = mapFileName && getNormalizedAbsolutePath(mapFileName, getDirectoryPath(generatedFileName));
        for (const location of possibleMapLocations) {
            const mapFileName = getNormalizedAbsolutePath(location, getDirectoryPath(generatedFileName));
            const mapFileContents = readMapFile(mapFileName, originalMapFileName);
            if (isString(mapFileContents)) {
                return convertDocumentToSourceMapper(host, mapFileContents, mapFileName);
            }
            if (mapFileContents !== undefined) {
                return mapFileContents || undefined;
            }
        }
        return undefined;
    }

    function convertDocumentToSourceMapper(host: DocumentPositionMapperHost, contents: string, mapFileName: string) {
        const map = tryParseRawSourceMap(contents);
        if (!map || !map.sources || !map.file || !map.mappings) {
            // obviously invalid map
            return undefined;
        }

        // Dont support sourcemaps that contain inlined sources
        if (map.sourcesContent && map.sourcesContent.some(isString)) return undefined;

        return createDocumentPositionMapper(host, map, mapFileName);
    }

    function createSourceFileLike(text: string, lineMap?: SourceFileLike["lineMap"]): SourceFileLike {
        return {
            text,
            lineMap,
            getLineAndCharacterOfPosition(pos: number) {
                return computeLineAndCharacterOfPosition(getLineStarts(this), pos);
            }
        };
    }
}