import * as path from 'path';

import * as fs from 'fs';

import readdirp, { EntryInfo } from 'readdirp';

const inputFolder = path.resolve('dist/packages/core');

const outputFolder = path.resolve('dist/packages/tns-core-modules');

const testImports: string[] = [];

// List of definition files that don't need to be exported.

const dtsBlacklist = ['global-types.d.ts', 'references.d.ts'];

// List of modules that should be re-exported despite they are private

const privateModulesWhitelist = [

'ui/styling/style-scope', //Reason: nativescript-dev-webpack generates code that imports this module

];

// There are few module using the "export default" syntax

// They should be handled differently when re-exporting

const modulesWithDefaultExports = ['utils/lazy'];

function traverseInputDir(fileFilter: string[], callback: (entry: EntryInfo) => void) {

return new Promise((resolve, reject) => {

readdirp(inputFolder, {

fileFilter,

directoryFilter: (di: EntryInfo) => {

return !di.path.startsWith('node_modules') && !di.path.startsWith('platforms');

},

})

.on('data', callback)

.on('error', reject)

.on('end', resolve);

});

}

function processPackageJsonFile(entry: EntryInfo) {

const dirPath = path.dirname(entry.path);

const outputFilePath = path.join(outputFolder, entry.path);

ensureDirectoryExistence(outputFilePath);

const json = require(entry.fullPath);

if (json.main) {

(<any>fs).copyFileSync(entry.fullPath, outputFilePath);

logFileCreated(outputFilePath);

addTestImport(dirPath);

const mainFile = path.join(dirPath, json.main);

createReExportFile(mainFile, '.ts');

addTestImport(mainFile);

}

}

function processDefinitionFile(entry: EntryInfo) {

if (dtsBlacklist.includes(entry.path)) {

return;

}

const relativeFilePathNoExt = entry.path.replace(/\.d\.ts$/, '');

// Re-export everything from d.ts file

createReExportFile(relativeFilePathNoExt, '.d.ts');

// This might be only a definitions file.

// So check if there is ts/js files before creating TS file with re-exports

const baseFile = path.join(inputFolder, relativeFilePathNoExt);

if (fs.existsSync(baseFile + '.ts') || fs.existsSync(baseFile + '.js') || (fs.existsSync(baseFile + '.android.ts') && fs.existsSync(baseFile + '.ios.ts')) || (fs.existsSync(baseFile + '.android.js') && fs.existsSync(baseFile + '.ios.js'))) {

createReExportFile(relativeFilePathNoExt, '.ts');

addTestImport(relativeFilePathNoExt);

}

}

function processTypeScriptFile(entry: EntryInfo) {

const relativeFilePathNoExt = entry.path.replace(/\.ts$/, '');

createReExportFile(relativeFilePathNoExt, '.ts');

addTestImport(relativeFilePathNoExt);

}

function createReExportFile(pathNoExt: string, ext: '.ts' | '.d.ts') {

const outputFile = path.join(outputFolder, pathNoExt + ext);

if (!fs.existsSync(outputFile)) {

ensureDirectoryExistence(outputFile);

let content = `export * from "@nativescript/core/${pathNoExt}";`;

if (modulesWithDefaultExports.includes(pathNoExt)) {

content = `import defExport from "@nativescript/core/${pathNoExt}";\n`;

content += `export default defExport;`;

}

fs.writeFileSync(outputFile, content);

logFileCreated(outputFile);

}

}

function ensureDirectoryExistence(filePath: string) {

const dirname = path.dirname(filePath);

if (fs.existsSync(dirname)) {

return true;

}

ensureDirectoryExistence(dirname);

fs.mkdirSync(dirname);

}

function logFileCreated(file: string) {

console.log(`CREATED: ${file}`);

}

function addTestImport(moduleName: string) {

testImports.push(moduleName);

}

function generateTestFile() {

const uniqueImports = Array.from(new Set(testImports)).sort();

const output: string[] = [];

output.push(`/* tslint:disable */`);

output.push(`import { compare, report } from "./module-compare";\n\n`);

uniqueImports.forEach((name) => {

const moduleName = name.replace(/[\.\/\-]/g, '_');

const compatName = `module_${moduleName}_compat`;

const coreName = `module_${moduleName}_core`;

output.push(`import * as ${coreName} from "@nativescript/core/${name}";`);

output.push(`import * as ${compatName} from "tns-core-modules/${name}";`);

output.push(`compare("${name}", ${coreName}, ${compatName});\n`);

});

output.push(`\n`);

output.push(`report();`);

const testFilePath = path.resolve('dist/generated-tests/tests.ts');

ensureDirectoryExistence(testFilePath);

fs.writeFileSync(testFilePath, output.join('\n'), 'utf8');

(<any>fs).copyFileSync(path.resolve('build/generated-compat-checks/module-compare.ts'), path.resolve('dist/generated-tests/module-compare.ts'));

console.log(`Compat tests generated: ${testFilePath}`);

}

function generateExportsForPrivateModules() {

privateModulesWhitelist.forEach((pathNoExt) => {

createReExportFile(pathNoExt, '.ts');

addTestImport(pathNoExt);

});

}

(async () => {

console.log(' ------> GENERATING FILES FORM PACKAGE.JSON');

// Traverse all package.json files and create:

// * .ts file with re-exports for the package.json/main

// * .d.ts file with re-exports for the package.json/types

await traverseInputDir(['package.json'], processPackageJsonFile);

console.log(' ------> GENERATING FILES FORM DEFINITIONS');

// Traverse all d.ts files and create

// * .d.ts file with re-exports for definitions for the .d.ts

// * .ts file with re-exports for the corresponding ts/js file (is such exists)

await traverseInputDir(['*.d.ts'], processDefinitionFile);

console.log(' ------> GENERATING FILES FROM TYPESCRIPT');

// Traverse all ts files which are not platform specific and create

// * .ts file with re-exports for the corresponding ts file

await traverseInputDir(['*(?<!.(d|android|ios)).ts'], processTypeScriptFile);

generateExportsForPrivateModules();

// Generate tests in

generateTestFile();

})().catch((e) => {

console.log('Error generating tns-core-modules files: ' + e);

});