import resolve from '@rollup/plugin-node-resolve';
import replace from '@rollup/plugin-replace';
import commonjs from '@rollup/plugin-commonjs';
import svelte from 'rollup-plugin-svelte';
import babel from '@rollup/plugin-babel';
import { terser } from 'rollup-plugin-terser';
import config from 'sapper/config/rollup.js';
import pkg from './package.json';
//import importResolver from "rollup-plugin-import-resolver";
import sveltePreprocess from 'svelte-preprocess';
import aliasPlugin from '@rollup/plugin-alias';

const mode = process.env.NODE_ENV;
const dev = mode === 'development';
const legacy = !!process.env.SAPPER_LEGACY_BUILD;

const onwarn = (warning, onwarn) =>
    (warning.code === 'MISSING_EXPORT' && /'preload'/.test(warning.message)) ||
    (warning.code === 'CIRCULAR_DEPENDENCY' && /[/\\]@sapper[/\\]/.test(warning.message)) ||
    onwarn(warning);


const tailwindConfig = require('./tailwind.config.js');
const { theme } = (tailwindConfig || {});
const tailwinded = {
    screens: theme.screens, colors: theme.colors,
    spacing: theme.spacing, boxShadow: theme.boxShadow,
    fontFamily: theme.fontFamily, fontSize: theme.fontSize, fontWeight: theme.fontWeight
};
const preprocess = sveltePreprocess({ postcss: true });
const aliases = aliasPlugin({
    //resolve: ['.svelte', '.js', '.ts', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.html'],
    entries: [

        {find: /^%$/, replacement: './src/components/index.js'},
        {find: /^&$/, replacement: './src/const/index.js'},

        {find: /^\$$/, replacement: './src/store/index.js'},
        {find: /^~$/, replacement: './src/utils/index.js'},

        {find: /^%/, replacement: './src/components/'},

        {find: /^#/, replacement: './static/'},

    ]
});
/*const alias = {
    ':': './src/actions/index.js',
    '?': './src/api/index.js',
    '@': './src/components/index.js',
    '*': './src/routes/index.js',
    '$': './src/store/index.js',
    '&': './src/utils/index.js',
    '#': './static'
};
const importResolve = importResolver({
    // a list of file extensions to check, default = ['.js']
    extensions: ['.js', '.ts'],
    // a list of aliases, default = {}
    //alias,
    // index file name without extension, default = 'index'
    indexFile: 'index',
});*/

export default {
    client: {
        input: config.client.input(),
        output: config.client.output(),
        plugins: [
            replace({
                'process.browser': true,
                'process.env.NODE_ENV': JSON.stringify(mode),
                'tailwinded': JSON.stringify(tailwinded)
            }),
            aliases,
            svelte({
                preprocess,
                dev,
                hydratable: true,
                emitCss: true
            }),
            //importResolve,
            resolve({
                browser: true,
                dedupe: ['svelte']
            }),
            commonjs(),

            legacy && babel({
                extensions: ['.js', '.mjs', '.html', '.svelte'],
                babelHelpers: 'runtime',
                exclude: ['node_modules/@babel/**'],
                presets: [
                    ['@babel/preset-env', {
                        targets: '> 0.25%, not dead'
                    }]
                ],
                plugins: [
                    '@babel/plugin-syntax-dynamic-import',
                    ['@babel/plugin-transform-runtime', {
                        useESModules: true
                    }]
                ]
            }),

            !dev && terser({
                module: true
            })
        ],

        preserveEntrySignatures: false,
        onwarn,
    },

    server: {
        input: config.server.input(),
        output: config.server.output(),
        plugins: [
            replace({
                'process.browser': false,
                'process.env.NODE_ENV': JSON.stringify(mode),
                'tailwinded': JSON.stringify(tailwinded)
            }),
            aliases,
            svelte({
                preprocess,
                generate: 'ssr',
                hydratable: true,
                dev
            }),
            //importResolve,
            resolve({
                dedupe: ['svelte']
            }),
            commonjs()
        ],
        external: Object.keys(pkg.dependencies).concat(require('module').builtinModules),

        preserveEntrySignatures: 'strict',
        onwarn,
    },

    serviceworker: {
        input: config.serviceworker.input(),
        output: config.serviceworker.output(),
        plugins: [
            resolve(),
            replace({
                'process.browser': true,
                'process.env.NODE_ENV': JSON.stringify(mode)
            }),
            commonjs(),
            !dev && terser()
        ],

        preserveEntrySignatures: false,
        onwarn,
    }
};