const UserError = require('vn-loopback/util/user-error');
const fs = require('fs-extra');
const path = require('path');

module.exports = Self => {
    Self.remoteMethodCtx('upload', {
        description: 'Uploads a file and inserts into dms model',
        accessType: 'WRITE',
        accepts: [
            {
                arg: 'id',
                type: 'Number',
                description: 'The entity id',
                required: true
            },
            {
                arg: 'collection',
                type: 'string',
                description: 'The collection name',
                required: true
            },
            {
                arg: 'fileName',
                type: 'string',
                description: 'The file name',
                required: true
            }],
        returns: {
            type: 'Object',
            root: true
        },
        http: {
            path: `/upload`,
            verb: 'POST'
        }
    });

    Self.upload = async ctx => {
        const models = Self.app.models;
        const TempContainer = models.TempContainer;
        const fileOptions = {};
        const args = ctx.args;

        let srcFile;
        try {
            const hasWriteRole = await models.ImageCollection.hasWriteRole(ctx, args.collection);
            if (!hasWriteRole)
                throw new UserError(`You don't have enough privileges`);

            if (process.env.NODE_ENV == 'test')
                throw new UserError(`You can't upload images on the test instance`);

            // Upload file to temporary path
            const tempContainer = await TempContainer.container(args.collection);
            const uploaded = await TempContainer.upload(tempContainer.name, ctx.req, ctx.result, fileOptions);
            const [uploadedFile] = Object.values(uploaded.files).map(file => {
                return file[0];
            });
            const file = await TempContainer.getFile(tempContainer.name, uploadedFile.name);
            srcFile = path.join(file.client.root, file.container, file.name);

            await models.Image.registerImage(args.collection, srcFile, args.fileName, args.id);
        } catch (e) {
            if (fs.existsSync(srcFile))
                await fs.unlink(srcFile);

            throw e;
        }
    };
};