const libs = `${process.cwd()}/libs`;

const log = require(`${libs}/log`)(module);

const _ = require('lodash');

class ReqQueryFields {
    constructor(fields = {}, fieldValues = {}) {
        // Exemplo de requisição: `/api/v1/enrollments?dims=state,region,location`

        // Parâmetros no campo query da requisição.
        // Exemplo de field:
        // ```js
        // {
        //    name: 'dims',
        //    field: true,
        //    where: false
        // }
        // ```
        // Array de valores aceitos pelo campo.
        // Exemplo de valor:
        // ```
        // {
        //     name: 'location',
        //     table: 'localizacao',
        //     tableField: 'descricao'
        //     resultField: 'location_name',
        //     where: {
        //         relation: '=',
        //         type: 'integer',
        //         field: 'id_localizacao',
        //         table: 'turma'
        //     },
        //     join: {
        //         primary: 'pk_localizacao_id',
        //         foreign: 'id_localizacao',
        //         foreignTable: 'turma'
        //     }
        // }
        // ```
        this.fields = fields;
        this.fieldValues = fieldValues;
    }

    addField(field) {
        // Parâmetro no campo query da requisição.
        // Exemplo de field:
        // ```
        // {
        //    name: 'dims',
        //    field: true,
        //    where: false,
        //    fieldValues: {}
        // }
        // ```
        if(typeof this.fields[field.name] === 'undefined') {
            log.debug("added field "+field.name);
            this.fields[field.name] = field;
        }
        return this;
    }

    addValue(fieldValue) {
        // Valor aceito por **todos** os campos.
        // Exemplo de valor:
        // ```
        // {
        //     name: 'location',
        //     table: 'localizacao',
        //     tableField: 'descricao'
        //     resultField: 'location_name',
        //     where: {
        //         relation: '=',
        //         type: 'integer',
        //         field: 'id_localizacao',
        //         table: 'turma'
        //     },
        //     join: {
        //         primary: 'pk_localizacao_id',
        //         foreign: 'id_localizacao',
        //         foreignTable: 'turma'
        //     }
        // }
        // ```
        if(typeof this.fieldValues[fieldValue.name] === 'undefined') {
            this.fieldValues[fieldValue.name] = fieldValue;
            log.debug("added value "+fieldValue.name);
        }
        return this;
    }

    addValueToField(fieldValue, field) {
        // Valor aceito **apenas** pelo campo `field`.
        if(typeof this.fields[field] === 'undefined') {
            // Se o campo não existe, lança uma exception
            throw 'No field with name ' +field+ ' defined';
        }
        if(typeof this.fields[field].values === 'undefined') {
            this.fields[field].values = {};
        }
        if(typeof this.fields[field].values[fieldValue.name] === 'undefined') {
            this.fields[field].values[fieldValue.name] = fieldValue;
            log.debug("added value "+fieldValue.name+ ' to field ' + field);
        }
        return this;
    }

    parse() {
        // Faz o parse dos valores que vem na requisição para objetos.
        return (req, res, next) => {
            // "Foreach" nos campos aceitos
            Object.keys(this.fields).map((key, index) => {
                let params = [];
                // f é o campo
                let f = this.fields[key];
                log.debug('f');
                log.debug(f);
                // Unimos os valores parametros globalmente com os aceitos apenas pelo campo
                let values = _.merge(this.fieldValues, f.values);
                // Fazemos um foreach nos parametros aceitos
                Object.keys(values).map((k, i) => {
                    let value = values[k];
                    log.debug('value');
                    log.debug(value);
                    // Pushamos o parametro
                    params.push(value.name);
                });
                let queryField = f.name;
                let arrayOfParams = params;
                // Criamos o atributo com o nome do **campo** no objeto `req` (nome do campo é 'filter', 'dims', 'search', etc)
                req[queryField] = {};
                if (req.query[queryField]) {
                    // Se há mais de um parametro no campo, eles estão separados por vírgula.
                    // Fazemos o split então para separar os valores
                    const params = req.query[queryField].split(',');
                    // Objeto temporário para guardar os parametros e seus valores.
                    const obj = {};
                    for (const param of params) {
                        // O parametro *pode* ter um valor (por exemplo: `state:41`).
                        // Fazemos o split e temos um array `['state', 41]`
                        const kv = param.split(':');
                        // Checa se há um valor. Se não tem, definimos como true.
                        obj[kv[0]] = (typeof kv[1] === 'undefined') ? true : kv[1];
                        // `obj` é agora `{kv[0]: kv[1]}` ou `{kv[0]: true}`.
                        // No exemplo `{'state': 41}`
                    }

                    // Se o array existe e não está vazio fazemos a interseção
                    if (typeof arrayOfParams !== 'undefined' && arrayOfParams.length > 0) {
                        // Fazemos a interseção das chaves de `obj` com o array `arrayOfParams`.
                        // O array resultante são as chaves aceitas pelo campo.
                        const intersection = _.intersection(arrayOfParams, Object.keys(obj));
                        // Isso é um pouco complicado...
                        // Para cada chave na interseção pegamos seu valor em `obj`
                        // e atribuímos para o atributo que definimos no objeto `req`.
                        // Por exemplo: intersection = `['state']` então
                        // `obj[intersection[i]]` (com i=0) é `obj['state']`, cujo valor é 41.
                        // Então fazemos `req[queryField]['state'] = 41`
                        for (let i = 0; i < intersection.length; ++i) {
                            req[queryField][intersection[i]] = obj[intersection[i]];
                        }
                        req[queryField].size = intersection.length;
                    } else {
                        req[queryField] = obj;
                        req[queryField].size = Object.keys(obj).length;
                    }
                }
            });
            next();
        };
    }

    build() {
        // "Constrói" o SQL
        return (req, res, next) => {
            // Foreach no campos
            Object.keys(this.fields).map((key, index) => {
                // Campo
                let field = this.fields[key];
                log.debug(field);
                // `param` aqui é o atributo no objeto `req` (dims, filter, search, ...)
                let param = req[field.name];
                log.debug('param');
                log.debug(param);
                // Fazemos um foreach nos parametros dentro do atributo
                Object.keys(param).map((k, i) => {
                    let values = _.merge(this.fieldValues, field.values);
                    log.debug('ValueS');
                    log.debug(values);
                    log.debug('k');
                    log.debug(k);
                    if(typeof values[k] !== 'undefined') {
                        // Clonamos para não alterar o original
                        let value = _.clone(values[k]);
                        log.debug(value);
                        // Checa se não fizemos o join para este valor e se é necessário fazer
                        if(!value.hasJoined && typeof value.join !== 'undefined') {
                            let foreignTable = '';
                            if(value.join.foreignTable) foreignTable = value.join.foreignTable+'.';
                            // Fazemos o join
                            req.sql.join(value.table, null, foreignTable+value.join.foreign+'='+value.table+'.'+value.join.primary);
                            // Marcamos o join como feito para não ter problemas
                            value.hasJoined = true;
                            if(typeof this.fieldValues !== 'undefined' && typeof this.fieldValues[k] !== 'undefined') this.fieldValues[k].hasJoined = true;
                            if(typeof field.values !== 'undefined' && typeof field.values[k] !== 'undefined') field.values[k].hasJoined = true;
                        }
                        // Se o valor é um campo a ser incluído no SELECT
                        if(typeof field.field !== 'undefined' && field.field) {
                            log.debug('SELECT');
                            req.sql.field(value.table+'.'+value.tableField, value.resultField || value.tableField)
                                .group(value.table+'.'+value.tableField)
                                .order(value.table+'.'+value.tableField);
                        }
                        // Se o valor é um campo para ser usado no WHERE
                        if(typeof field.where !== 'undefined' && field.where) {
                            log.debug('WHERE');
                            // Valor do where
                            let whereValue = param[k];
                            // Valor sempre vem como string, necessário fazer parse para o banco
                            if(value.where.type === 'integer') whereValue = parseInt(whereValue, 10);
                            if(value.where.type === 'double') whereValue = parseFloat(whereValue);
                            if(value.where.type === 'string') whereValue = '%'+whereValue+'%';
                            let tbl = value.where.table || value.table;
                            let whereField = (value.where.type === 'string')? 'LOWER('+tbl+'.'+value.where.field+')' : tbl+'.'+value.where.field;
                            let lower = (value.where.type === 'string') ? ' LOWER(?) ' : ' ? ';
                            req.sql.where(whereField + ' ' + value.where.relation + lower, whereValue);
                        }
                    }
                });
            });
            next();
        };
    }
}

module.exports = ReqQueryFields;