require('../connections/mysql-server');
require('../helpers/CheckToken');
require('../helpers/config');
const formidable = require('formidable');
const express = require('express');
const router = express.Router();
const bodyParser = require('body-parser');

var accessToken = "b78050152a551b71665045f03a2161fa";
var clientSecret = "VumfHSuZcTIAe6hyvHgrRGv+UVX9xEQlX1HqFgiA+7DDhLIIXt1hjy2mP3Ht/MQyYs++ja8Ok5+aWabRRJ5uGY+dQDIlmZGeWpplffT6VowLOLe6JEYH4OLdmv5sNQtR";
var clientIDVimeo = "addbd91428cb667f7c5d50e47626ddb8554170cb";

router.use(bodyParser.urlencoded({
    parameterLimit: 100000,
    limit: '2000mb',
    extended: true
}));
router.use(bodyParser.json({
    parameterLimit: 100000,
    limit: '2000mb',
    extended: true
}));

const routes = function () {

    router.get('/', verifyJWT, (req, res) => {
        execSQLQuery(`SELECT
            *
        FROM media;`, res, req.originalUrl);
    });

    router.get('/getAllMedia', (req, res) => {
        execSQLQuery(`SELECT
            *
        FROM media;`, res, req.originalUrl);
    });

    router.get('/getMedia/:idmedia', verifyJWT, (req, res) => {
        const idmedia = parseInt(req.params.idmedia);
        execSQLQuery(`SELECT
            *
        FROM media
        WHERE idmedia = ${idmedia};`, res, req.originalUrl);
    });

    router.get('/viewvideo/:_key', (req, res) => {
        var _key = req.params._key;
        execSQLQueryVideo(`SELECT * FROM videoaccess WHERE _key = '${_key}' AND expired = 0`, res, req.originalUrl);
    });

    router.post('/insertVA', verifyJWT, (req, res) => {
        const idvideoaccess = req.body.idvideoaccess;
        const _key = (req.body._key).trim();
        const expired = req.body.expired ? 1 : 0;
        const url = req.body.url;
        const tag = req.body.tag;

        execSQLQuery(`INSERT INTO videoaccess(_key, expired, url, tag)
        VALUES (?, ?, ?, ?);`, res, req.originalUrl, [_key, expired, url, tag]);
    });

    router.patch('/updateVA', verifyJWT, (req, res) => {
        const idvideoaccess = req.body.idvideoaccess;
        const _key = (req.body._key).trim();
        const expired = req.body.expired ? 1 : 0;
        const url = req.body.url;
        execSQLQuery(`UPDATE videoaccess SET
            _key = ?,
            expired = ?,
            url = ?
        WHERE idvideoaccess = ?;`, res, req.originalUrl, [_key, expired, url, idvideoaccess]);
    });

    router.get('/getVA/:tag', verifyJWT, (req, res) => {
        const tag = req.params.tag;
        execSQLQuery(`SELECT * FROM videoaccess WHERE tag = '${tag}' AND expired = 0;`, res, req.originalUrl);
    });

    router.post('/insertMedia', verifyJWT, (req, res) => {
        const idmedia = req.body.idmedia;
        const description = req.body.description;
        const publishid = req.body.publishid;
        const type = req.body.type;
        execSQLQuery(`INSERT INTO media(description, publishid, type)
        VALUES (?, ?, ?);`, res, req.originalUrl, [description, publishid, type]);
    });

    router.patch('/updateMedia', verifyJWT, (req, res) => {
        const idmedia = req.body.idmedia;
        const description = req.body.description;
        const publishid = req.body.publishid;
        const type = req.body.type;
        execSQLQuery(`UPDATE media SET
            description = ?,
            publishid = ?,
            type = ?
        WHERE idmedia = ?;`, res, req.originalUrl, [description, publishid, type, idmedia]);
    });

    router.get('/backVideo/:idvideo/:Online', (req, res) => {
        var idvideos = req.params.idvideo;
        var dir = Variables('src_media') + 'videos/tmp/var/www/html/videos/' + idvideos + '.mp4';
        const fs = require('fs');

        if (fs.existsSync(dir)) {
            console.log("Requisição de vídeo: " + idvideos);
            res.send(true);
        }
        else {
            const shell = require('shelljs');
            shell.exec(`unzip -o -P "${Variables('passdecrypt')}" ${Variables('src_media')}videos/${idvideos}.zip -d ${Variables('src_media')}videos/tmp/`, function (ResExtract) {
                console.log("RESULTADO: " + ResExtract);
                if (ResExtract == 0) { // EXTRAIDO COM SUCESSO
                    shell.exec(`chmod -R 777 ${Variables('src_media')}videos/tmp/`);
                    if (fs.existsSync(dir)) {
                        console.log("Requisição de vídeo: " + idvideos);
                        res.send(true);
                    }
                    else {
                        res.send(false);
                    }
                }
                else { // ERRO AO EXTRAIR ( BAIXA O ARQUIVO DO SERVIDOR E REPRODUZ NO VIMEO )
                    shell.exec('cd ' + Variables('src_media') + 'videos/;wget http://18.228.91.135/videos/' + idvideos + '.zip', function (sucesso) {
                        console.log(sucesso);
                    });
                    res.send(false);
                }
            });
            /*require('all-unpacker').unpack(Variables('src_media') + 'videos/' + idvideos + '.zip', {
            targetDir: Variables('src_media')  + 'videos/tmp/',
            password: Variables('passdecrypt'),
            forceOverwrite: true,
            }, function(err, files, text) {
                if (err) {
                    console.error(err);
                    shell.exec('cd ' + Variables('src_media') + 'videos/;wget http://18.228.91.135/videos/' + idvideos + '.zip', function (sucesso) {
                        console.log(sucesso);
                    });
                    if (check == 0) {
                        res.redirect("https://player.vimeo.com/video/" + idvideos);
                    }
                    else {
                        res.send(false);
                    }
                }
                if (files) console.log('files', files);
                if (text) {
                    console.log('text', text);
                    fs.readFile(dir, (err, data) => {
                        if (err) throw err;
                        console.log("Requisição de vídeo: " + idvideos);
                        if (check == 0) {
                            res.setHeader('Content-Type', 'video/mp4');
                            res.send(data);
                        }
                        else {
                            res.send(true);
                        }
                    });
                    //res.redirect(dir);
                };
            });*/
        }
    });

    router.get('/deleteVideo/:publishid', verifyJWT, (req, res) => {
        const publishid = req.params.publishid;
        let Vimeo = require('vimeo').Vimeo;
        let client = new Vimeo(clientIDVimeo, clientSecret, accessToken);
        client.request({
            method: 'DELETE',
            path: '/videos/' + publishid,
        }, function (error, body, status_code, headers) {
            mysqlConnection.query(`DELETE FROM media WHERE publishid = '${publishid}';`, function (error, results, fields) {
                const fs = require('fs');
                fs.unlink(Variables('src_media') + 'videos/' + publishid + '.zip', function(Sucesso) {
                    res.send(JSON.stringify({
                        "status": 200,
                        "error": error,
                        "response": results
                    }));
                    console.log(req.originalUrl + "/ success 200");
                });
            });
        });
    })

    let uploads = {};

    router.post('/uploadwithProgress', verifyJWT, (req, res, next) => {
        let fs = require('fs');
        let fileId = req.headers['x-file-id'];
        let startByte = parseInt(req.headers['x-start-byte'], 10);
        let name = req.headers['name'];
        let fileSize = parseInt(req.headers['size'], 10);
        let Copiar = req.headers['Copiar'] || "1";
        let ext = '.mp4';
        console.log('file Size', fileSize, fileId, startByte);
        if (uploads[fileId] && fileSize == uploads[fileId].bytesReceived) {
            res.end();
            return;
        }
        console.log(fileSize);

        if (!fileId) {
            res.writeHead(400, "No file id");
            res.end(400);
        }
        console.log(uploads[fileId]);
        if (!uploads[fileId])
            uploads[fileId] = {};

        let upload = uploads[fileId]; //Bytes of file already present

        let fileStream;

        let Caminho = `${Variables('src_media')}videos/`;
        let dir = `${Caminho}${name}`;

        //checking bytes of file uploaded and sending to server
        if (!startByte) {
            upload.bytesReceived = 0;
            let name = req.headers['name'];
            fileStream = fs.createWriteStream(dir + ext, {
                flags: 'w' //with "w"(write stream ) it keeps on adding data
            });
        } else {
            if (upload.bytesReceived != startByte) {//if same name file is sent with different size it will not upload
                res.writeHead(400, "Wrong start byte");
                res.end(upload.bytesReceived);
                return;
            }
            // append to existing file
            fileStream = fs.createWriteStream(dir + ext, {
                flags: 'a'
            });
        }
        req.on('data', function (data) {
            upload.bytesReceived += data.length; //adding length of data we are adding
        });
        req.pipe(fileStream);
        // when the request is finished, and all its data is written
        fileStream.on('close', function () {
            console.log(upload.bytesReceived, fileSize);
            if (upload.bytesReceived == fileSize) {
                console.log("Upload finished");
                delete uploads[fileId];

                // can do something else with the uploaded file here

                UploadVimeo(name, dir + ext, function(URI) {
                    if (URI == false) {
                        // ERRO
                        fs.unlink(dir + ext, function(Sucesso) {
                            res.send({ 'status': 'falhou' });
                            res.end();
                        })
                    }
                    else {
                        // SUCESSO
                        let novoNome = URI.split('/')[2];
                        if (Copiar ==  "1") {
                            fs.rename(dir + ext, Caminho + novoNome + ext, function(Sucesso) {
                                zipVideoSync(novoNome, Caminho + novoNome, function(Sucesso) {
                                    res.send({ 'status': 'uploaded', 'uri': URI });
                                    res.end();
                                });
                            })
                        }
                        else {
                            fs.unlink(dir + ext, function(Sucesso) {
                                res.send({ 'status': 'uploaded', 'uri': URI });
                                res.end();
                            })
                        }
                    }
                })

            } else {
                // connection lost, leave the unfinished file around
                console.log("File unfinished, stopped at " + upload.bytesReceived);
                res.writeHead(500, "Server Error");
                res.end();
            }
        });

        // in case of I/O error - finish the request
        fileStream.on('error', function (err) {
            console.log("fileStream error", err);
            res.writeHead(500, "File error");
            res.end();
        });

    });

    router.get('/status', verifyJWT, (req, res) => {
        //console.log('Successfully came');
        //From GET request 3 parameters below and store in variable
        let fileId = req.headers['x-file-id'];
        let name = req.headers['name'];
        let fileSize = parseInt(req.headers['size'], 10);
        console.log(name);
        if (name) {
            try {
                let stats = fs.statSync(`${Variables('src_media')}videos/${name}`); //grabs file information and returns
                //checking file exists or not
                if (stats.isFile()) {
                    console.log(`fileSize is ${fileSize} and already uploaded file size ${stats.size}`);
                    if (fileSize == stats.size) {
                        res.send({ 'status': 'file is present' }) //returns if file exists
                        return;
                    }
                    if (!uploads[fileId])
                        uploads[fileId] = {}
                    console.log(uploads[fileId]);
                    uploads[fileId]['bytesReceived'] = stats.size;//checks total amount of file uploaded
                    console.log(uploads[fileId], stats.size);
                }
            } catch (er) {

            }

        }
        let upload = uploads[fileId];
        if (upload)
            res.send({ "uploaded": upload.bytesReceived });//returns to FrontEnd amout of bytes uploaded
        else
            res.send({ "uploaded": 0 });

    });

    router.get('/SolucaoProblemas/:publishid/:tentativa', verifyJWT, (req, res) => {
        const publishid = req.params.publishid;
        const tentativa = parseInt(req.params.tentativa);
        const fs = require('fs');
        if (tentativa == 1) {
            fs.unlink(Variables('src_media') + 'videos/tmp/var/www/html/videos/' + publishid + '.mp4', function(Sucesso) {
                console.log("Video MP4 excluido com sucesso!");
                res.send(true);
            });
        }
        else {
            fs.unlink(Variables('src_media') + 'videos/' + publishid + '.zip', function(Sucesso) {
                console.log("Video ZIP excluido com sucesso!");
                fs.unlink(Variables('src_media') + 'videos/tmp/var/www/html/videos/' + publishid + '.mp4', function(Sucesso) {
                    console.log("Video MP4 excluido com sucesso!");
                    res.send(true);
                });
            });
        }
    });

    return router;
};

function UploadVimeo(description, oldpath, callback) {
    let Vimeo = require('vimeo').Vimeo;
    let client = new Vimeo(clientIDVimeo, clientSecret, accessToken);
    client.upload(
        oldpath,
    {
        'name': description,
        'description': description
    },
    function (uri) {
        console.log('Your video URI is: ' + uri);
        callback(uri);
    },
    function (bytes_uploaded, bytes_total) {
        var percentage = (bytes_uploaded / bytes_total * 100).toFixed(2)
        console.log(bytes_uploaded, bytes_total, percentage + '%')
    },
    function (error) {
        console.log('Failed because: ' + error)
        callback(false);
    })
}

function zipVideoSync(name, dir, callback) {
    const fs = require('fs');
    require('all-unpacker').pack(Variables('src_media') + 'videos/' + name + '.zip', {
        targetDir: Variables('src_media')  + 'videos/' + name + '.mp4',
        password: Variables('passdecrypt'),
        }, function(err, files, text) {
            if (err) return console.error(err);
            if (files) console.log('files', files);
            if (text) {
                console.log('text', text);
                if(fs.unlinkSync(dir + '.mp4'))
                    console.log("Falha ao excluir");
                else
                    console.log("Excluído com sucesso!");
                callback(true);
            };
        });
}

module.exports = routes;

/*
                    //função pack - inserida no index.js da biblioteca all-unpacker//

        unpackAll.pack = function pack(archiveFile, options, callback) {
        if (!callback) return new Error('No callback function');
        if (!archiveFile) archiveFile = options.archiveFile;
        if (!archiveFile) return callback(Error("Error: archiveFile or options.archiveFile missing."), null);
        if (!options) options = {};

        var unar = options.unar;
        if (!unar) unar = (process.platform != "linux") ? path.join(__dirname,'zip') : 'zip';
        var ar = [unar];

        if (options.password) {
            ar.push('-P');
            ar.push(options.password);
        }

        ar.push('SOURCEFILE');

        var targetDir = options.targetDir;
        ar.push(targetDir);

        var cmd  = quote(ar).replace('SOURCEFILE', archiveFile);
        exec_unar(cmd, targetDir, callback);
    };
                    */