const mysql = require('mysql2/promise');
const exec = require('child_process').exec;
const fs = require('fs-extra');
const path = require('path');
const colors = require('colors');
const axios = require('axios');
const yml = require('require-yml');

const selectQuery = fs.readFileSync(`sql/selectQueued.sql`).toString();
const jobDataQuery = fs.readFileSync(`sql/jobData.sql`).toString();
const jobArgsQuery = fs.readFileSync(`sql/jobArgs.sql`).toString();
const updateQuery = fs.readFileSync(`sql/updateState.sql`).toString();
const appDir = path.dirname(require.main.filename);

class PrintServer {
    async start() {
        let conf = yml(path.join(__dirname, 'config.yml'));
        const localConfFile = path.join(__dirname, 'config.local.yml');
        if (fs.existsSync(localConfFile))
            conf = Object.assign({}, conf, yml(localConfFile));
        this.conf = conf;

        const decoration = '△▽'.repeat(10)
        console.clear();
        console.log(decoration, `${colors.bgBlack.white.bold(' Print')}${colors.bgBlack.green.bold('Natura ')}`, decoration, '\n')
        await this.getToken();
        await this.init();
    }
    async init() {
        this.conn = await mysql.createConnection(this.conf.db);
        this.dbErrorHandler = err => this.onDbError(err);
        this.conn.on('error', this.dbErrorHandler);
        console.log('Connected to DB successfully.'.green);
        await this.poll();
    }
    async stop() {
        await this.end();
        await axios.post(`${this.conf.salix.url}/api/Accounts/logout?access_token=${this.token}`);
    }
    async end() {
        if (this.pollTimeout) {
            clearTimeout(this.pollTimeout);
            this.pollTimeout = null;
        }
        if (this.reconnectTimeout) {
            clearTimeout(this.reconnectTimeout);
            this.reconnectTimeout = null;
        }
        this.conn.off('error', this.dbErrorHandler);
        // FIXME: mysql2/promise bug, conn.end() ends process
        this.conn.on('error', () => {});
        await this.conn.end();
    }
    async getToken() {
        const salix = this.conf.salix;
        let response = await axios.post(`${salix.url}/api/Accounts/login`, {
            user: salix.user,
            password: salix.password
        });
        this.token = response.data.token;
    }
    async onDbError(err) {
        switch(err.code) {
            case 'PROTOCOL_CONNECTION_LOST':
            case 'ECONNRESET':
            case 1927: // ER_CONNECTION_KILLED
                console.error(`DB: ${err.message}`.red);
                try {
                    await this.end();
                } catch(e) {}
                console.log('Waiting until DB is available again...'.yellow);
                await this.reconnect();
                break;
        }
    }
	async reconnect() {
        this.reconnectTimeout = null;
		try {
            await this.init();
		} catch (err) {
			this.reconnectTimeout = setTimeout(
                () => this.reconnect(), this.conf.reconnectTimeout * 1000);
		}
	}
    async poll() {
        this.pollTimeout = null;
        try {
            await this.printJob();
        } catch (err) {
            console.error(err)
        }
        this.pollTimeout = setTimeout(() => this.poll(), this.conf.refreshRate);
    }
    async printJob() {
        const conn = this.conn;
        const conf = this.conf;
        let printJob;
        let jobId;

        try {
            await conn.beginTransaction();
            [[printJob]] = await conn.query(selectQuery);
            if (!printJob) {
                await conn.rollback();
                return;
            }

            jobId = printJob.id;

            await conn.query(updateQuery, ['printing', null, jobId]);
            await conn.commit();
        } catch (err) {
            await conn.rollback();
            throw err;
        }

        try {
            // Job data
            // FIXME: Cannot read property 'method' of undefined
            const [[jobData]] = await conn.query(jobDataQuery, jobId);
            const args = {};
            const [res] = await conn.query(jobArgsQuery, jobId);
            for (const row of res)
                args[row.name] = row.value;
            
            // Path params
            const usedParams = new Set();
            const methodPath = jobData.method.replace(/{\w+}/g, function(match) {
                const key = match.substr(1, match.length - 2);
                const value = args[key];
                usedParams.add(key);
                return value !== undefined ? value : match;
            });

            let pdfData;
            for (let attempts = 0; !pdfData && attempts < 2; attempts++) {
                // URL params
                const params = {
                    access_token: this.token,
                    userFk: printJob.userFk
                };
                for (const key in args) {
                    if (!usedParams.has(key))
                        params[key] = args[key];
                }
                const urlParams = new URLSearchParams(params);

                // Request
                try {
                    const response = await axios({
                        method: 'get',
                        url: `${conf.salix.url}/api/${methodPath}?${urlParams.toString()}`,
                        responseType: 'arraybuffer',
                        headers: {
                            'Accept': 'application/pdf'
                        }
                    });
                    pdfData = response.data;  
                }
                catch (err) {
                    if (err.response?.statusText === 'Unauthorized') {
                        await this.getToken();
                    } else
                        throw err;
                }
            }

            // Save PDF to disk
            const printer = jobData.printer;
            const tmpPath = path.join(appDir, 'tmp')
            if (!fs.existsSync(tmpPath))
                fs.mkdirSync(tmpPath)
            const tmpFilePath = path.join(tmpPath, `${Math.random().toString(36).substring(7)}.pdf`);
            await fs.writeFile(tmpFilePath, pdfData, 'binary');

            // Print PDF
            try {
                await pExec(`lp -d "${printer}" "${tmpFilePath}"`);
            } catch(err) {
                await fs.unlink(tmpFilePath);
                throw new Error(`Print error: ${err.message}`);
            } 

            await conn.query(updateQuery, ['printed', null, jobId]);

            if (conf.debug)
                console.debug(`(${colors.yellow(jobId)}) Document has been printed`, `[${args.collectionFk}, ${jobData.report}, ${printer}]`.green);

            await fs.unlink(tmpFilePath);
        } catch (err) {
            let message = err.message;
            if (err.name === 'AxiosError' && err.code === 'ERR_BAD_REQUEST') {
                const resMessage = JSON.parse(err.response.data).error.message;
                message = `${message}: ${resMessage}`;
            }

            await conn.query(updateQuery, ['error', message, jobId]);
            throw new Error(`(${jobId}) ${message}`);
        }
    }
}

module.exports = PrintServer;

function pExec(command) {
	return new Promise(function(resolve, reject) {
		exec(command, function(err, stdout, stderr) {
			if (err) return reject(err);
			resolve({stdout, stderr})
		});
	});
}