require('./utils');

const sinon = require('sinon');

const scope = require('../lib/scope');
const {parse} = require('../');

describe('Parser', function () {
    var parserError = /^Query Error: unexpected character in filter at char/;

    describe('Simple Expressions', function () {
        it('should parse simple id & value combos', function () {
            parse('id:3').should.eql({id: 3});

            parse('slug:getting-started').should.eql({slug: 'getting-started'});
        });
    });

    describe('Comparison Query Operators', function () {
        it('can parse standard equals', function () {
            parse('count:5').should.eql({count: 5});

            parse('tag:getting-started').should.eql({tag: 'getting-started'});

            parse('author:\'Joe Bloggs\'').should.eql({author: 'Joe Bloggs'});

            parse('author:123-test').should.eql({author: '123-test'});
        });

        it('can parse not equals', function () {
            parse('count:-5').should.eql({count: {$ne: 5}});

            parse('tag:-getting-started').should.eql({tag: {$ne: 'getting-started'}});

            parse('author:-\'Joe Bloggs\'').should.eql({author: {$ne: 'Joe Bloggs'}});
        });

        it('can parse greater than', function () {
            parse('count:>5').should.eql({count: {$gt: 5}});

            parse('tag:>getting-started').should.eql({tag: {$gt: 'getting-started'}});

            parse('author:>\'Joe Bloggs\'').should.eql({author: {$gt: 'Joe Bloggs'}});
        });

        it('can parse less than', function () {
            parse('count:<5').should.eql({count: {$lt: 5}});

            parse('tag:<getting-started').should.eql({tag: {$lt: 'getting-started'}});

            parse('author:<\'Joe Bloggs\'').should.eql({author: {$lt: 'Joe Bloggs'}});
        });

        it('can parse greater than or equals', function () {
            parse('count:>=5').should.eql({count: {$gte: 5}});

            parse('tag:>=getting-started').should.eql({tag: {$gte: 'getting-started'}});

            parse('author:>=\'Joe Bloggs\'').should.eql({author: {$gte: 'Joe Bloggs'}});
        });

        it('can parse less than or equals', function () {
            parse('count:<=5').should.eql({count: {$lte: 5}});

            parse('tag:<=getting-started').should.eql({tag: {$lte: 'getting-started'}});

            parse('author:<=\'Joe Bloggs\'').should.eql({author: {$lte: 'Joe Bloggs'}});
        });

        it('can parse IN with single value', function () {
            parse('count:[5]').should.eql({count: {$in: [5]}});

            parse('tag:[getting-started]').should.eql({tag: {$in: ['getting-started']}});

            parse('author:[\'Joe Bloggs\']').should.eql({author: {$in: ['Joe Bloggs']}});
        });

        it('can parse NOT IN with single value', function () {
            parse('count:-[5]').should.eql({count: {$nin: [5]}});

            parse('tag:-[getting-started]').should.eql({tag: {$nin: ['getting-started']}});

            parse('author:-[\'Joe Bloggs\']').should.eql({author: {$nin: ['Joe Bloggs']}});
        });

        it('can parse IN with multiple values', function () {
            parse('count:[5, 8, 12]').should.eql({count: {$in: [5, 8, 12]}});

            parse('tag:[getting-started, ghost, really-long-1]')
                .should.eql({tag: {$in: ['getting-started', 'ghost', 'really-long-1']}});

            parse('author:[\'Joe Bloggs\', \'John O\\\'Nolan\', \'Hello World\']')
                .should.eql({author: {$in: ['Joe Bloggs', 'John O\'Nolan', 'Hello World']}});
        });

        it('can parse NOT IN with multiple values', function () {
            parse('count:-[5, 8, 12]').should.eql({count: {$nin: [5, 8, 12]}});

            parse('tag:-[getting-started, ghost, really-long-1]')
                .should.eql({tag: {$nin: ['getting-started', 'ghost', 'really-long-1']}});

            parse('author:-[\'Joe Bloggs\', \'John O\\\'Nolan\', \'Hello World\']')
                .should.eql({author: {$nin: ['Joe Bloggs', 'John O\'Nolan', 'Hello World']}});
        });

        it('can parse CONTAINS, STARTSWITH and ENDSWITH with and without NOT', function () {
            parse(`email:~'gmail.com'`).should.eql({email: {$regex: /gmail\.com/i}});

            parse(`email:-~'gmail.com'`).should.eql({email: {$not: /gmail\.com/i}});

            parse(`email:~^'gmail.com'`).should.eql({email: {$regex: /^gmail\.com/i}});

            parse(`email:-~^'gmail.com'`).should.eql({email: {$not: /^gmail\.com/i}});

            parse(`email:~$'gmail.com'`).should.eql({email: {$regex: /gmail\.com$/i}});

            parse(`email:-~$'gmail.com'`).should.eql({email: {$not: /gmail\.com$/i}});
        });

        it('can parse CONTAINS, STARTSWITH and ENDSWITH and handle regexchars', function () {
            parse(`email:~'.*+?^$(){}|[]\\'`).should.eql({email: {$regex: /\.\*\+\?\^\$\(\)\{\}\|\[\]\\/i}});
        });

        it('can parse CONTAINS, STARTSWITH and ENDSWITH and handle quotes', function () {
            parse(`name:~'john o\\'nolan'`).should.eql({name: {$regex: /john o'nolan/i}});

            parse(`name:~'john o\\"nolan'`).should.eql({name: {$regex: /john o"nolan/i}});

            // TODO: Fix this BUG
            (function () {
                parse(`name:~'john o"nolan'`);
            }).should.throw();

            // This will probably never be possible
            (function () {
                parse(`name:~'john o'nolan'`);
            }).should.throw();
        });
    });

    describe('Values', function () {
        it('can parse null', function () {
            parse('image:null').should.eql({image: null});
        });

        it('can parse NOT null', function () {
            parse('image:-null').should.eql({image: {$ne: null}});
        });

        it('can parse true', function () {
            parse('featured:true').should.eql({featured: true});
        });

        it('can parse NOT true', function () {
            parse('featured:-true').should.eql({featured: {$ne: true}});
        });

        it('can parse false', function () {
            parse('featured:false').should.eql({featured: false});
        });

        it('can parse NOT false', function () {
            parse('featured:-false').should.eql({featured: {$ne: false}});
        });

        it('can parse a Number', function () {
            parse('count:5').should.eql({count: 5});
        });

        it('can parse NOT a Number', function () {
            parse('count:-5').should.eql({count: {$ne: 5}});
        });
    });

    describe('Logical Query Operators', function () {
        // @TODO support implicit and?
        it('$and', function () {
            parse('page:false+status:published')
                .should.eql({$and: [{page: false}, {status: 'published'}]});
        });

        // @TODO or with same property is in?
        it('$or', function () {
            parse('page:true,featured:true')
                .should.eql({$or: [{page: true}, {featured: true}]});

            parse('page:true,page:false')
                .should.eql({$or: [{page: true}, {page: false}]});
        });
    });

    describe('Grouping', function () {
        it('ungroups top level group', function () {
            parse('(status:published)').should.eql({status: 'published'});
        });

        it('ungroups top level group with logical query operator', function () {
            parse('(page:false+status:published)')
                .should.eql({$and: [{page: false}, {status: 'published'}]});
        });

        it('ungroups top level group with nested groups', function () {
            parse('(page:false,(status:published+featured:true))')
                .should.eql({
                    $or: [
                        {page: false},
                        {
                            $and: [
                                {status: 'published'},
                                {featured: true}
                            ]
                        }
                    ]
                });
        });
    });

    describe('complex examples', function () {
        it('Many expressions', function () {
            parse('tag:photo+featured:true,tag.count:>5').should.eql({
                $or: [
                    {$and: [{tag: 'photo'}, {featured: true}]},
                    {'tag.count': {$gt: 5}}
                ]
            });

            parse('tag:photo+image:-null,tag.count:>5').should.eql({
                $or: [
                    {$and: [{tag: 'photo'}, {image: {$ne: null}}]},
                    {'tag.count': {$gt: 5}}
                ]
            });
        });

        describe('Logical Groups', function () {
            describe('$or', function () {
                it('ungrouped version', function () {
                    parse('author:-joe,tag:photo,image:-null,featured:true').should.eql(
                        {$or: [
                            {author: {$ne: 'joe'}},
                            {tag: 'photo'},
                            {image: {$ne: null}},
                            {featured: true}
                        ]}
                    );
                });

                it('RIGHT grouped version', function () {
                    parse('author:-joe,(tag:photo,image:-null,featured:true)').should.eql(
                        {$or: [
                            {author: {$ne: 'joe'}},
                            {$or: [
                                {tag: 'photo'},
                                {image: {$ne: null}},
                                {featured: true}
                            ]}
                        ]}
                    );
                });

                it('LEFT grouped version', function () {
                    parse('(tag:photo,image:-null,featured:true),author:-joe').should.eql(
                        {$or: [
                            {$or: [
                                {tag: 'photo'},
                                {image: {$ne: null}},
                                {featured: true}
                            ]},
                            {author: {$ne: 'joe'}}
                        ]}
                    );
                });
            });

            describe('$and', function () {
                it('ungrouped version', function () {
                    parse('author:-joe+tag:photo+image:-null+featured:true').should.eql(
                        {$and: [
                            {author: {$ne: 'joe'}},
                            {tag: 'photo'},
                            {image: {$ne: null}},
                            {featured: true}
                        ]}
                    );
                });

                it('RIGHT grouped version', function () {
                    parse('author:-joe+(tag:photo+image:-null+featured:true)').should.eql(
                        {$and: [
                            {author: {$ne: 'joe'}},
                            {$and: [
                                {tag: 'photo'},
                                {image: {$ne: null}},
                                {featured: true}
                            ]}
                        ]}
                    );
                });

                it('LEFT grouped version', function () {
                    parse('(tag:photo+image:-null+featured:true)+author:-joe').should.eql(
                        {$and: [
                            {$and: [
                                {tag: 'photo'},
                                {image: {$ne: null}},
                                {featured: true}
                            ]},
                            {author: {$ne: 'joe'}}
                        ]}
                    );
                });
            });

            describe('$or with $and group', function () {
                it('ungrouped version', function () {
                    parse('author:-joe,tag:photo+image:-null+featured:true').should.eql(
                        {$or: [
                            {author: {$ne: 'joe'}},
                            {$and: [
                                {tag: 'photo'},
                                {image: {$ne: null}},
                                {featured: true}
                            ]}
                        ]}
                    );
                });

                it('RIGHT grouped version', function () {
                    parse('author:-joe,(tag:photo+image:-null+featured:true)').should.eql(
                        {$or: [
                            {author: {$ne: 'joe'}},
                            {$and: [
                                {tag: 'photo'},
                                {image: {$ne: null}},
                                {featured: true}
                            ]}
                        ]}
                    );
                });

                it('LEFT grouped version', function () {
                    parse('(tag:photo+image:-null+featured:true),author:-joe').should.eql(
                        {$or: [
                            {$and: [
                                {tag: 'photo'},
                                {image: {$ne: null}},
                                {featured: true}
                            ]},
                            {author: {$ne: 'joe'}}
                        ]}
                    );
                });
            });

            describe('$and with $or group', function () {
                it('ungrouped version', function () {
                    parse('author:-joe+tag:photo,image:-null,featured:true').should.eql(
                        {$or: [
                            {$and: [
                                {author: {$ne: 'joe'}},
                                {tag: 'photo'}
                            ]},
                            {image: {$ne: null}},
                            {featured: true}
                        ]}
                    );
                });

                it('RIGHT grouped version', function () {
                    parse('author:-joe+(tag:photo,image:-null,featured:true)').should.eql(
                        {$and: [
                            {author: {$ne: 'joe'}},
                            {$or: [
                                {tag: 'photo'},
                                {image: {$ne: null}},
                                {featured: true}
                            ]}
                        ]}
                    );
                });

                it('LEFT grouped version', function () {
                    parse('(tag:photo,image:-null,featured:true)+author:-joe').should.eql(
                        {$and: [
                            {$or: [
                                {tag: 'photo'},
                                {image: {$ne: null}},
                                {featured: true}
                            ]},
                            {author: {$ne: 'joe'}}
                        ]}
                    );
                });
            });

            describe('combo', function () {
                it('RIGHT grouped version', function () {
                    parse(
                        'name:sample,(name:-sample+created_at:<=\'2016-03-03\'),(name:-sample+(created_at:\'2016-03-03\',created_at:\'2016-03-04\'))'
                    ).should.eql(
                        {$or: [
                            {name: 'sample'},
                            {$and: [
                                {name: {$ne: 'sample'}},
                                {created_at: {$lte: '2016-03-03'}}
                            ]},
                            {$and: [
                                {name: {$ne: 'sample'}},
                                {$or: [
                                    {created_at: '2016-03-03'},
                                    {created_at: '2016-03-04'}
                                ]}
                            ]}
                        ]}
                    );
                });

                it('LEFT grouped version', function () {
                    parse(
                        '(name:-sample,(created_at:\'2016-03-03\',created_at:\'2016-03-04\')),(name:-sample+created_at:<=\'2016-03-03\'),name:sample'
                    ).should.eql(
                        {$or: [
                            {$or: [
                                {name: {$ne: 'sample'}},
                                {$or: [
                                    {created_at: '2016-03-03'},
                                    {created_at: '2016-03-04'}
                                ]}
                            ]},
                            {$and: [
                                {name: {$ne: 'sample'}},
                                {created_at: {$lte: '2016-03-03'}}
                            ]},
                            {name: 'sample'}
                        ]}
                    );
                });
            });
        });

        it('in expressions', function () {
            parse('author:-joe+tag:[photo,video]').should.eql(
                {$and: [
                    {author: {$ne: 'joe'}},
                    {tag: {$in: ['photo', 'video']}}
                ]}
            );

            parse('author:-joe+tag:-[photo,video,audio]').should.eql(
                {$and: [
                    {author: {$ne: 'joe'}},
                    {tag: {$nin: ['photo', 'video', 'audio']}}
                ]}
            );

            parse('author:-joe+tag:[photo,video,magic,\'audio\']+post.count:>5+post.count:<100').should.eql(
                {$and: [
                    {author: {$ne: 'joe'}},
                    {tag: {$in: ['photo', 'video', 'magic', 'audio']}},
                    {'post.count': {$gt: 5}},
                    {'post.count': {$lt: 100}}
                ]}
            );
        });
    });

    describe('whitespace rules', function () {
        it('will ignore whitespace in expressions', function () {
            parse('count: -5').should.eql(parse('count:-5'));
            parse('author: -joe + tag: [photo, video]').should.eql(parse('author:-joe+tag:[photo,video]'));
        });

        it('will not ignore whitespace in Strings', function () {
            parse('author:\'Hello World\'').should.not.eql(parse('author:\'HelloWorld\''));
        });
    });

    describe('invalid expressions', function () {
        it('CANNOT parse characters outside of a STRING value', function () {
            (function () {
                parse('tag:\'My Tag\'-');
            }).should.throw(parserError);
        });

        it('CANNOT parse property - operator - value in wrong order', function () {
            (function () {
                parse('\'My Tag\':tag');
            }).should.throw(parserError);
            (function () {
                parse('5>:tag');
            }).should.throw(parserError);
        });

        it('CANNOT parse combination without filter expression', function () {
            (function () {
                parse('count:3+');
            }).should.throw(parserError);
            (function () {
                parse(',count:3');
            }).should.throw(parserError);
        });

        it('CANNOT parse incomplete group', function () {
            (function () {
                parse('id:5,(count:3');
            }).should.throw(parserError);
            (function () {
                parse('count:3)');
            }).should.throw(parserError);
            (function () {
                parse('id:5(count:3)');
            }).should.throw(parserError);
        });

        it('CANNOT parse invalid IN expression', function () {
            (function () {
                parse('id:[test+ing]');
            }).should.throw(parserError);
            (function () {
                parse('id:[test');
            }).should.throw(parserError);
            (function () {
                parse('id:test,ing]');
            }).should.throw(parserError);
        });
    });

    describe('Aliases', function () {
        it('can handle empty aliases', function () {
            parse('tag:getting-started', {aliases: {}})
                .should.eql({tag: 'getting-started'});
        });

        it('can expand a field alias', function () {
            parse('tag:getting-started', {aliases: {tag: 'tags.slug'}})
                .should.eql({'tags.slug': 'getting-started'});
        });

        it('can expand multiple field aliases', function () {
            parse('tag:getting-started+author:joe', {aliases: {tag: 'tags.slug', author: 'authors.slug'}})
                .should.eql({$and: [{'tags.slug': 'getting-started'}, {'authors.slug': 'joe'}]});
        });
    });

    describe('Relative dates', function () {
        describe('relDateToAbsolute is called correctly', function () {
            let relDateToAbsoluteStub;

            beforeEach(function () {
                relDateToAbsoluteStub = sinon.stub(scope, 'relDateToAbsolute');
            });

            afterEach(function () {
                sinon.restore();
            });

            it('last_seen_at:>=now-2d', function () {
                parse('last_seen_at:>=now-2d');
                sinon.assert.calledWithExactly(relDateToAbsoluteStub, 'sub', '2', 'd');
            });

            it('last_seen_at:>=now+365d', function () {
                parse('last_seen_at:<=now+365d');

                sinon.assert.calledWithExactly(relDateToAbsoluteStub, 'add', '365', 'd');
            });

            it('last_seen_at:>=now-12w', function () {
                parse('last_seen_at:>=now-12w');
                sinon.assert.calledWithExactly(relDateToAbsoluteStub, 'sub', '12', 'w');
            });

            it('last_seen_at:>=now+2M', function () {
                parse('last_seen_at:<=now+2M');

                sinon.assert.calledWithExactly(relDateToAbsoluteStub, 'add', '2', 'M');
            });

            it('last_seen_at:>=now-2y', function () {
                parse('last_seen_at:>=now-2y');
                sinon.assert.calledWithExactly(relDateToAbsoluteStub, 'sub', '2', 'y');
            });

            it('last_seen_at:>=now+2h', function () {
                parse('last_seen_at:<=now+2h');

                sinon.assert.calledWithExactly(relDateToAbsoluteStub, 'add', '2', 'h');
            });

            it('last_seen_at:>=now+2m', function () {
                parse('last_seen_at:<=now+2m');

                sinon.assert.calledWithExactly(relDateToAbsoluteStub, 'add', '2', 'm');
            });

            it('last_seen_at:>=now+2s', function () {
                parse('last_seen_at:<=now+2s');

                sinon.assert.calledWithExactly(relDateToAbsoluteStub, 'add', '2', 's');
            });
        });

        describe('call to relDateToAbsolute results in the correct date format', function () {
            let relDateToAbsoluteSpy;

            beforeEach(function () {
                // spy lets requests through
                relDateToAbsoluteSpy = sinon.spy(scope, 'relDateToAbsolute');
            });

            afterEach(function () {
                sinon.restore();
            });

            it('can expand a relative date into an absolute date', function () {
                // This test proves that the date is in the right format, but not that it is the right date
                const subRes = parse('last_seen_at:>=now-2d');
                subRes.should.be.an.Object().with.property('last_seen_at');
                subRes.last_seen_at.should.be.an.Object().with.property('$gte');
                subRes.last_seen_at.$gte.should.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

                const addRes = parse('last_seen_at:<=now+2d');
                addRes.should.be.an.Object().with.property('last_seen_at');
                addRes.last_seen_at.should.be.an.Object().with.property('$lte');
                addRes.last_seen_at.$lte.should.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

                sinon.assert.calledTwice(relDateToAbsoluteSpy);
            });
        });
    });
});