import * as path from 'path';

import { ConfigSettingsArg, ConfigSettingsBuilder, ConfigSettingsBuilderOptions, EnvConfigSettings  } from '../../src';
import { configRootsDir } from '../helpers';

// import { ConfigSettingsBuilder } from '../../builder/ConfigSettingsBuilder';
// import { ConfigSettingsArg, ConfigSettingsBuilderOptions, EnvConfigSettings } from '../../builder/types';

describe('ConfigSettingsBuilder', () => {
    const build = async (
        args: ConfigSettingsArg | ConfigSettingsArg[],
        options?: ConfigSettingsBuilderOptions
    ) => {
        return ConfigSettingsBuilder.build(args, options);
    };

    const baseNameAsFileRoot = path.join(configRootsDir, 'baseNameAsFile');
    const baseNameAsDirRoot = path.join(configRootsDir, 'baseNameAsDir');
    const mergedRoot = path.join(configRootsDir, 'merged');
    const refsRoot = path.join(configRootsDir, 'refs');

    it('Should load settings file defined with file named with baseName', async () => {
        const args: ConfigSettingsArg = {
            rootPath: baseNameAsFileRoot,
            baseName: 'settings',
        };
        const settings = await build(args);
        expect(settings).toHaveProperty('setting1', 'value1');
    });

    it('Should load settings file defined with directory named with baseName and file named base', async () => {
        const args: ConfigSettingsArg = {
            rootPath: baseNameAsDirRoot,
            baseName: 'settings',
        };
        const settings = await build(args);
        expect(settings).toHaveProperty('setting1', 'value1');
    });

    it('Should load settings from base and file with baseName development when NODE_ENV = development, over-riding base values with those defined in NODE_ENV named file', async () => {
        process.env.NODE_ENV = 'development';
        const args: ConfigSettingsArg = {
            rootPath: mergedRoot,
            baseName: 'settings',
        };
        const settings = await build(args);
        expect(settings).toHaveProperty('setting1', 'baseValue1');
        expect(settings).toHaveProperty('setting2', 'devValue2');
        expect(settings).toHaveProperty('setting3', 'devValue3');
    });

    it('Should load settings from base and file with baseName production when NODE_ENV = production, over-riding base values with those defined in NODE_ENV named file', async () => {
        process.env.NODE_ENV = 'production';
        const args: ConfigSettingsArg = {
            rootPath: mergedRoot,
            baseName: 'settings',
        };
        const settings = await build(args);
        expect(settings).toHaveProperty('setting1', 'baseValue1');
        expect(settings).toHaveProperty('setting2', 'prodValue2');
        expect(settings).toHaveProperty('setting3', 'prodValue3');
    });

    it('Should merge values defined in environment variables over base and NODE_ENV settings ', async () => {
        process.env.NODE_ENV = 'development';
        process.env.TEST_SETTING_3 = 'envValue3';
        const args: ConfigSettingsArg = {
            rootPath: mergedRoot,
            baseName: 'settings',
        };
        const settings = await build(args);
        expect(settings).toHaveProperty('setting1', 'baseValue1');
        expect(settings).toHaveProperty('setting2', 'devValue2');
        expect(settings).toHaveProperty('setting3', 'envValue3');
    });

    it('Should handle builder arg that is a function/factory', async () => {
        const argVal: ConfigSettingsArg = {
            rootPath: baseNameAsFileRoot,
            baseName: 'settings',
        };
        const args = () => argVal;

        const settings = await build(args);
        expect(settings).toHaveProperty('setting1', 'value1');
    });

    it('Should handle builder arg that is a function/factory with Promise', async () => {
        const getDataPromise = num =>
            new Promise((resolve, reject) => {
                setTimeout(() => {
                    typeof num === 'number' ? resolve(num * 2) : reject('Input must be an number');
                }, 200);
            });

        const args = async () => {

            const setting2 = await getDataPromise(4);
            return {
                setting1: 'value1',
                setting2,
            };

        } 

        const settings = await build(args);
        expect(settings).toHaveProperty('setting1', 'value1');
        expect(settings).toHaveProperty('setting2', 8);
    });

    it('Should handle EnvConfigSettings defined in code', async () => {

        process.env.NODE_ENV = 'development';
        const envSettings: EnvConfigSettings = {
            base: {
                a: 1,
                b: 2,
            },
            nodeEnv: {
                development: {
                    a: 3,
                }
            }
        }

        const settings = await build(envSettings);
        expect(settings).toHaveProperty('a', 3);
        expect(settings).toHaveProperty('b', 2);

        // setting3: TEST_SETTING_3

    });    

    it('Should handle EnvConfigSettings and env vars defined in code', async () => {

        process.env.NODE_ENV = 'development';
        process.env.TEST_SETTING_A = 'valueAFromEnv';
        process.env.TEST_SETTING_C1 = 'valueC1FromEnv';
        const envSettings: EnvConfigSettings = {
            base: {
                a: 1,
                b: 2,
                c: {
                    c1: 3,
                    c2: 4
                }
            },
            nodeEnv: {
                development: {
                    a: 3,
                }
            },
            envVars: {
                a: 'TEST_SETTING_A',
                c: {
                    c1: 'TEST_SETTING_C1'
                }
            }
        }

        const settings = await build(envSettings);
        expect(settings).toHaveProperty('a', 'valueAFromEnv');
        expect(settings).toHaveProperty('c.c1', 'valueC1FromEnv');
        expect(settings).toHaveProperty('c.c2', 4);
        expect(settings).toHaveProperty('b', 2);

    });    

});