const mix = require('laravel-mix');

mix.js('resources/js/app.js', 'public/js');

const fs = require('fs-extra');

const env = process.env.APP_ENV;

const compile = process.env.APP_COMPILE ? process.env.APP_COMPILE : 'production';

const production = mix.inProduction();

const localProd = (!production || env === 'local');

const compileDev = (env === 'local' && compile === 'dev');

const productionProd = (production && env === 'production');

console.info(env, compileDev, production, localProd, productionProd);


// copy director / files
function copyDir(src, dest) {
    try {

        const exists = fs.pathExistsSync(dest);

        if (!exists) {

            const options = {
                mode: 0o2775
            };

            fs.ensureDirSync(dest, options);
        }

        fs.emptyDirSync(dest);

        fs.copySync(src, dest);

        console.info(`Directory Copied from ${src} to ${dest} Successfully!`);

    } catch (err) {

        console.info(`Directory Copy operation from ${src} to ${dest} Failed!`);

        console.info(err);
    }
}


async function toJson(file, object, options) {
    try {
        await fs.writeJson(file, object, options);
        console.info(`Write to json ${file} Success!`);
    } catch (err) {
        console.info(err)
        console.info(`Write to json ${file} Failed!`);
    }
}



function getArray() {

    let jsfiles = [];
    this.jsdiry;
    this.extras;
    this.output;

    let getFiles = function(dir) {
        try {
            return fs.readdirSync(dir).filter(file => {
                return fs.statSync(`${dir}/${file}`).isFile();
            });
        } catch (info) {
            const fs = require('fs');
            return fs.readdirSync(dir).filter(file => {
                return fs.statSync(`${dir}/${file}`).isFile();
            });
        }
    };

    this.addFiles = function(directory, extras, output) {

        this.jsdiry = directory;

        this.extras = extras ? extras : [];

        this.output = output ? output : 'public/';

        getFiles(this.jsdiry).forEach(function(filepath, index) {

            jsfiles[index] = `${directory}${filepath}`;

        });

        if (typeof this.extras === 'object') {

            this.extras.forEach(extra => {

                jsfiles.push(extra);

            });

        } else if (typeof this.extra === 'string') {

            jsfiles.push(this.extras);

        }
    }

    this.getFiles = function() {
        return jsfiles;
    }

    this.getOutputPath = function() {
        return this.output;
    }

}



const copyAssets = [

    {
        src: 'resources/css',
        dest: 'public/css',
        type: 'directory'
    },
    {
        src: 'resources/img',
        dest: 'public/img',
        type: 'directory'
    },
    {
        src: 'resources/js',
        dest: 'public/js',
        type: 'directory'
    },
    {
        src: 'resources/css/style.css',
        dest: 'public/css/style.css',
        type: 'file'
    },
];


const compileAssets = [];

// if (compileDev) {
//     compileAssets.push({
//         src: 'vaccination/applicant-registration.js',
//         dest: 'public/js/applicant-registration.js',
//         type: 'vue'
//     });

// }

if (!compileDev) {
    copyAssets.push({
        src: 'resources/img',
        dest: 'public/img',
        type: 'directory'
    });
}

copyAssets.forEach((asset, index) => {

    try {
        fs.accessSync(asset.src, fs.constants.F_OK);

        if (asset.type == 'directory') {

            mix.copyDirectory(asset.src, asset.dest);

        } else {

            if (!!asset.min) {

                mix.copy(asset.src, asset.dest).version();

                mix.minify(asset.dest).version();

            } else {

                mix.copy(asset.src, asset.dest).version();
            }

        }
    } catch (err) {
        console.info(err);
    }


});
compileAssets.forEach((asset, index) => {

    try {
        fs.accessSync(asset.src, fs.constants.F_OK);

        switch (asset.type) {
            case 'js':

                mix.js(asset.src, asset.dest)
                    .minify(asset.dest)
                    .sourceMaps(production, 'source-map')
                    .version();
                break;

            case 'vue':

                mix.js(asset.src, asset.dest)
                    .vue({
                        version: 2
                    })
                    .minify(asset.dest)
                    .sourceMaps(production, 'source-map')
                    .version();

                break;

        }
    } catch (err) {
        console.info(err);
    }


});





const sassFiles = new getArray();

// sassFiles.addFiles('resources/assets/scss/');

// const sassOutputFiles = sassFiles.getFiles();

// sassOutputFiles.forEach((file, index) => {

//     try {
//         fs.accessSync(file, fs.constants.F_OK);

//         mix.sass(file, 'public/css/');
//     } catch (err) {
//         console.info(err);
//     }


// });

// const jsFiles = new getArray();

// jsFiles.addFiles('resources/assets/js/additionals/');

// const jsOutPutFiles = jsFiles.getFiles();

// jsOutPutFiles.forEach((file, index) => {

//     try {
//         fs.accessSync(file, fs.constants.F_OK);

//         mix.js(file, 'public/js/')
//             .sourceMaps(production, 'source-map')
//             .version();
//     } catch (err) {
//         console.info(err);
//     }


// });

if (production) {
    mix.options({
            autoprefixer: {
                remove: false
            },
            processCssUrls: true,
            purifyCss: false,
            terser: {},
            postCss: [
                require('autoprefixer')
            ],
            clearConsole: false,
            cssNano: {
                discardComments: {
                    removeAll: true
                },
            }
        })
        .disableNotifications();
}


mix.after(stats => {

    if (compileDev) {

        const copyForProduction = [


            {
                key: null,
                src: './public/img',
                dest: './resources/img',
                type: 'dir'
            },

        ];

        const assets = Object.keys(stats.compilation.assets);

        copyForProduction.forEach((asset, index) => {

            try {

                if (asset.key !== null && asset.type === 'file' && assets[asset.key] !== 'undefined') {

                    fs.copyFile(asset.src, asset.dest, (err) => {
                        if (err) {
                            console.info(`Copy ${asset.src} to ${asset.dest} Failed`);
                            throw err;
                        }
                        console.info(`Copied ${asset.src} to ${asset.dest} Successfully`);
                    });

                } else {

                    copyDir(asset.src, asset.dest);
                }
            } catch (e) {

                console.info(e);

            }


        });
    }

    try {
        const mixManifestoPath = "public/mix-manifest.json";
        const manifestoSrcPath = "resources/manifest.json";

        fs.writeFile(mixManifestoPath,
            JSON.stringify(Object.assign(
                    fs.readJsonSync(manifestoSrcPath),
                    fs.readJsonSync(mixManifestoPath)),
                null,
                4));

    } catch (err) {
        console.info("Manifesto Could not be written! : " + err);
    }
});