import {Router} from "express";
import * as fs from "fs";
import path from "path";
import config from "config";
import ApplicationComponent from "../ApplicationComponent";
import {logger} from "../Logger";
import {ServerError} from "../HttpError";
import * as crypto from "crypto";
import {compile, preprocess} from "svelte/compiler";
import requireFromString from "require-from-string";
import {sveltePreprocess} from "svelte-preprocess/dist/autoProcess";
import chokidar from "chokidar";
import {CssResult} from "svelte/types/compiler/interfaces";

const BACKEND_CODE_PREFIX = 'swaf.';
const COMPILED_SVELTE_EXTENSION = '.swafview';

export default class FrontendToolsComponent extends ApplicationComponent {
    public static getSveltePreCompileSeparator(file: string): string {
        return '\n---' + crypto.createHash('sha1').update(path.basename(path.resolve(file))).digest('base64') + '---\n';
    }

    private content: Map<string, string> = new Map();

    public constructor(
        private readonly publicAssetsPath: string,
        private readonly svelteViewsPath: string,
        private readonly svelteOutputPath: string,
    ) {
        super();

        if (!fs.existsSync(svelteOutputPath)) {
            fs.mkdirSync(svelteOutputPath);
        }
    }

    public async start(): Promise<void> {
        await this.cachePublicAssets();

        await this.preCompileSvelteViews();

        const watcher = chokidar.watch(this.svelteViewsPath, {persistent: true});
        watcher.on('ready', () => {
            logger.debug('Watching svelte assets for changes');

            watcher.on('add', (path) => {
                this.preCompileSvelte(path)
                    .catch(logger.error);
            });

            watcher.on('change', (path) => {
                this.preCompileSvelte(path)
                    .catch(logger.error);
            });
        });
    }

    private async cachePublicAssets(): Promise<void> {
        if (config.get<boolean>('view.enable_asset_cache')) {
            logger.info('Caching assets from', this.publicAssetsPath, '...');
            await this.forEachFileInDirRecursively(this.publicAssetsPath, file => this.cacheFile(file));
        } else {
            logger.info('Asset cache disabled.');
        }
    }

    private async preCompileSvelteViews(): Promise<void> {
        logger.info('Pre-compiling svelte views...');
        await this.forEachFileInDirRecursively(this.svelteViewsPath, async file => {
            if (file.endsWith('.svelte')) {
                await this.preCompileSvelte(file);
            }
        });
    }

    public async handle(router: Router): Promise<void> {
        router.use((req, res, next) => {
            res.locals.inlineAsset = (urlPath: string) => {
                if (!config.get<boolean>('view.enable_asset_cache')) {
                    return fs.readFileSync(path.resolve(this.publicAssetsPath + urlPath));
                }

                const content = this.content.get(urlPath);
                if (!content) {
                    throw new ServerError('Asset ' + path + ' was not loaded.');
                }
                return content;
            };
            next();
        });
    }

    private async forEachFileInDirRecursively(dir: string, consumer: (file: string) => Promise<void>): Promise<void> {
        await new Promise<void[]>((resolve, reject) => {
            fs.readdir(dir, (err, files) => {
                if (err) return reject(err);

                resolve(Promise.all<void>(files.map(file => new Promise<void>((resolve, reject) => {
                    file = path.join(dir, file);
                    fs.stat(file, (err, stat) => {
                        if (err) return reject(err);

                        if (stat.isDirectory()) {
                            resolve(this.forEachFileInDirRecursively(file, consumer));
                        } else {
                            resolve(consumer(file));
                        }
                    });
                }))));
            });
        });
    }

    private async cacheFile(file: string): Promise<void> {
        await new Promise<void>((resolve, reject) => {
            fs.readFile(file, (err, data) => {
                if (err) return reject(data);

                const urlPath = file.replace(this.publicAssetsPath, '');
                this.content.set(urlPath, data.toString());
                logger.debug('Loaded', file, 'as', urlPath);
                resolve();
            });
        });
    }

    private async preCompileSvelte(file: string): Promise<void> {
        logger.debug('Pre-compiling', file);
        const source = await new Promise<string>((resolve, reject) => {
            fs.readFile(file, (err, data) => {
                if (err) return reject(err);

                resolve(data.toString());
            });
        });

        const {backendReplacedCode, backendLines} = this.replaceBackendCode(source);

        const preprocessed = await this.preprocessSvelte(backendReplacedCode, file);

        // Server Side Render (initial HTML, no-js)
        const ssr = this.compileSvelteSsr(preprocessed.code, file, preprocessed.sourcemap);

        // Actual svelte
        const svelte = this.compileSvelteJS(preprocessed.code, preprocessed.sourcemap);

        const separator = FrontendToolsComponent.getSveltePreCompileSeparator(file);
        const finalCode = [
            [...backendLines.values()].join('\n'),
            ssr.head,
            ssr.html,
            ssr.css.code,
            ssr.css.map,
            svelte.code,
            svelte.map,
        ].join(separator);

        const newFile = path.join(this.svelteOutputPath, path.basename(file) + COMPILED_SVELTE_EXTENSION);
        await new Promise<void>((resolve, reject) => fs.writeFile(newFile, finalCode, err => {
            if (err) return reject(err);
            resolve();
        }));
    }

    private replaceBackendCode(code: string): {
        backendReplacedCode: string,
        backendLines: string[],
    } {
        if (code.indexOf(`export let swaf = {};`) < 0) {
            return {
                backendReplacedCode: code,
                backendLines: [],
            };
        }

        const backendLines = new Set<string>();

        let index = 0;
        while ((index = code.indexOf(BACKEND_CODE_PREFIX, index + 1)) >= 0) {
            // Escaping
            if (index > 0 && code[index - 1] === '\\') {
                const isEscapingEscaped = index > 1 && code[index - 2] === '\\';
                code = code.substring(0, index - 1 - (isEscapingEscaped ? 1 : 0)) +
                    code.substring(index, code.length);
                continue;
            }

            const startIndex = index + BACKEND_CODE_PREFIX.length;
            let endIndex = startIndex;
            let struct = 0;

            while (endIndex < code.length) {
                if (['(', '[', '{'].indexOf(code[endIndex]) >= 0) struct++;
                if ([')', ']', '}'].indexOf(code[endIndex]) >= 0) {
                    struct--;
                    if (struct <= 0) {
                        if (struct === 0) endIndex++;
                        break;
                    }
                }
                if ([' ', '\n', '<'].indexOf(code[endIndex]) >= 0 && struct === 0) break;
                endIndex++;
            }

            const backendLine = code.substring(startIndex, endIndex);
            backendLines.add(backendLine);
            code = code.substring(0, index) +
                'swaf(`' + backendLine.replace(/([^\\])`/, '$1\\`') + '`)' +
                code.substring(endIndex, code.length);
        }

        logger.silly('Replaced backend code');

        return {
            backendReplacedCode: code,
            backendLines: [...backendLines],
        };
    }

    private async preprocessSvelte(code: string, filename: string): Promise<{
        code: string,
        sourcemap?: SourceMap,
    }> {
        const preprocessed = await preprocess(
            code,
            sveltePreprocess({
                typescript: {
                    tsconfigFile: 'tsconfig.views.json',
                },
            }),
            {
                filename: filename,
            },
        );

        return {
            code: preprocessed.code,
            sourcemap: preprocessed.map as (SourceMap | undefined),
        };
    }

    private compileSvelteSsr(code: string, filename: string, sourcemap?: SourceMap): {
        head: string,
        css: CssResult,
        html: string,
    } {
        const svelteSsr = compile(code, {
            dev: false,
            generate: 'ssr',
            format: 'cjs',
            sourcemap: sourcemap,
            cssOutputFilename: filename + '.css',
        });

        return requireFromString(svelteSsr.js.code, filename).default.render({
            swaf: () => 'undefined',
        });
    }

    private compileSvelteJS(code: string, sourcemap?: SourceMap): {
        code: string,
        map: SourceMap,
    } {
        const compiled = compile(code, {
            dev: false,
            hydratable: true,
            sourcemap: sourcemap,
        });
        return {
            code: compiled.js.code,
            map: compiled.js.map,
        };
    }
}

export type SourceMap = string | Record<string, unknown> | undefined;