inspect_orig = require('util').inspect
inspect = (x) -> inspect_orig(x, false, null)
deep_equal = require('deep-equal')
chai = require('chai')
assert = chai.assert
expect = chai.expect
should = chai.should
{ Parser } = require('../lib/bloodyroots')

String.prototype.repeat = (num) ->
    new Array( num + 1 ).join( this );

describe 'Parser', ->
    describe 'unit testing', ->
        describe 'at_least_one', ->
            class TestParser extends Parser
                @define_production('Document', @at_least_one(@re('abc')))

            p = new TestParser()

            describe 'with none', ->
                r = p.parse('dabc')
                
                it 'should not parse', -> assert not r?

            describe 'with one', ->
                r = p.parse('abcdef')
                r_correct = `{ pos: 0,
                    length: 3,
                    type: 'seq',
                    seq: [ { pos: 0, length: 3, type: 're', match: 'abc', groups: [ 'abc' ] } ] }`
    
                it 'should parse', -> assert deep_equal(r, r_correct)
        
            describe 'with two', ->
                r = p.parse('abcabcdef')
                r_correct = `{ pos: 0,
                    length: 6,
                    type: 'seq',
                    seq: [ { pos: 0, length: 3, type: 're', match: 'abc', groups: [ 'abc' ] },
                        { pos: 3, length: 3, type: 're', match: 'abc', groups: [ 'abc' ] } ] }`
        
                it 'should parse', -> assert deep_equal(r, r_correct)
        
        describe 'zero_or_more', ->
            class TestParser extends Parser
                @define_production('Document', @zero_or_more(@re('abc')))

            p = new TestParser()

            describe 'with none', ->
                r = p.parse('dabc')
                r_correct = `{ pos: 0,
                    length: 0,
                    type: 'seq',
                    seq: [ ] }`
                
                it 'should parse', -> assert deep_equal(r, r_correct)

            describe 'with one', ->
                r = p.parse('abcdef')
                r_correct = `{ pos: 0,
                    length: 3,
                    type: 'seq',
                    seq: [ { pos: 0, length: 3, type: 're', match: 'abc', groups: [ 'abc' ] } ] }`
    
                it 'should parse', -> assert deep_equal(r, r_correct)
        
            describe 'with two', ->
                r = p.parse('abcabcdef')
                r_correct = `{ pos: 0,
                    length: 6,
                    type: 'seq',
                    seq: [ { pos: 0, length: 3, type: 're', match: 'abc', groups: [ 'abc' ] },
                        { pos: 3, length: 3, type: 're', match: 'abc', groups: [ 'abc' ] } ] }`
        
                it 'should parse', -> assert deep_equal(r, r_correct)
        
        describe 'zero_or_one', ->
            class TestParser extends Parser
                @define_production('Document', @zero_or_one(@re('abc')))

            p = new TestParser()

            describe 'with none', ->
                r = p.parse('dabc')
                r_correct = `{ pos: 0,
                    length: 0,
                    type: 'seq',
                    seq: [ ] }`
                
                it 'should match zero times', -> assert deep_equal(r, r_correct)

            describe 'with one', ->
                r = p.parse('abcdef')
                r_correct = `{ pos: 0,
                    length: 3,
                    type: 'seq',
                    seq: [ { pos: 0, length: 3, type: 're', match: 'abc', groups: [ 'abc' ] } ] }`
    
                it 'should match one time', -> assert deep_equal(r, r_correct)
        
            describe 'with two', ->
                r = p.parse('abcabcdef')
                r_correct = `{ pos: 0,
                    length: 3,
                    type: 'seq',
                    seq: [ { pos: 0, length: 3, type: 're', match: 'abc', groups: [ 'abc' ] } ] }`
        
                it 'should match one time', -> assert deep_equal(r, r_correct)

        describe 'alternation', ->
            describe 'parsing abcde with (abc|ab)cde', ->
                # suffix
                describe 'with suffix', ->
                    class TestParser extends Parser
                        @define_production('Document', @alternation( [ @re('abc'), @re('ab') ], @re('cde')))
                    p = new TestParser()
                    r = p.parse('abcde')

                    it 'should parse', -> assert r? and r.length == 5

                describe 'without suffix', ->
                    class TestParser extends Parser
                        @define_production('Document', @seq(@alternation(@re('abc'), @re('ab')), @re('cde')))
                    p = new TestParser()
                    r = p.parse('abcde')

                    it 'should not parse', -> assert not r?
                    
        describe 'range', ->
            describe 'parsing abc{m}abc{k}def with abc{i,j}def', ->
                for i in [0..6]
                    do (i) ->
                        for j in [0..6].concat(undefined)
                            do (j) ->
                                for k in [0..1]
                                    do (k) ->
                                        # non-greedy no-suffix
                                        class TestParser extends Parser
                                            @define_production('Document', @seq(@range(@re('abc'), i, j, false), @re('abc'.repeat(k) + 'def')))
                                        p = new TestParser()

                                        for m in [0..5]
                                            do (m) ->
                                                describe 'with non-greedy no-suffix m=%d k=%d i=%d j=%d'.sprintf(m,k,i,j), ->
                                                    r = p.parse('abc'.repeat(m) + 'def')

                                                    if i + k == m and (not j? or i <= j)
                                                        it 'should succeed', -> assert r?
                                                    else
                                                        it 'should fail', -> assert not r?

                                        # greedy no-suffix
                                        class TestParser extends Parser
                                            @define_production('Document', @seq(@range(@re('abc'), i, j, true), @re('abc'.repeat(k) + 'def')))
                                        p = new TestParser()

                                        for m in [0..5]
                                            do (m) ->
                                                describe 'with greedy no-suffix m=%d k=%d i=%d j=%d'.sprintf(m,k,i,j), ->
                                                    r = p.parse('abc'.repeat(m) + 'def')

                                                    if k == 0
                                                        if i <= m and (not j? or j >= m)
                                                            it 'should succeed', -> assert r?
                                                        else
                                                            it 'should fail', -> assert not r?
                                                    else
                                                        if j? and j + k == m and i <= j
                                                            it 'should succeed', -> assert r?
                                                        else
                                                            it 'should fail', -> assert not r?

                                        # non-greedy suffix
                                        class TestParser extends Parser
                                            @define_production('Document', @range(@re('abc'), i, j, false, @re('abc'.repeat(k) + 'def')))
                                        p = new TestParser()

                                        for m in [0..5]
                                            do (m) ->
                                                describe 'with non-greedy suffix m=%d k=%d i=%d j=%d'.sprintf(m,k,i,j), ->
                                                    r = p.parse('abc'.repeat(m) + 'def')

                                                    if i + k <= m and (not j? or j + k >= m)
                                                        it 'should succeed', -> assert r?
                                                    else
                                                        it 'should fail', -> assert not r?

                                        # greedy suffix
                                        class TestParser extends Parser
                                            @define_production('Document', @range(@re('abc'), i, j, true, @re('abc'.repeat(k) + 'def')))
                                        p = new TestParser()

                                        for m in [0..5]
                                            do (m) ->
                                                describe 'with greedy suffix m=%d k=%d i=%d j=%d'.sprintf(m,k,i,j), ->
                                                    r = p.parse('abc'.repeat(m) + 'def')

                                                    if i + k <= m and (not j? or j + k >= m)
                                                        it 'should succeed', -> assert r?
                                                    else
                                                        it 'should fail', -> assert not r?

            # distinguishes between greedy suffix and non-greedy suffix
            describe 'parsing ab{k}babab with ([ab]{2}){i,j}bab', ->
                for i in [0..6]
                    do (i) ->
                        for j in [0..6].concat(undefined)
                            do (j) ->
                                # non-greedy suffix
                                class TestParser extends Parser
                                    @define_production('Document', @range(@re('[ab]{2}'), i, j, false, @re('bab')))
                                p = new TestParser()

                                for k in [0..5]
                                    do (k) ->
                                        describe 'with non-greedy suffix {%d,%d} on ab{%d}babab'.sprintf(i,j,k), ->
                                            r = p.parse('ab'.repeat(k) + 'babab')

                                            if not j? or (i <= j and j >= k)
                                                if i <= k
                                                    it 'should have length %d'.sprintf(3+2*k), -> assert r.length == 3+2*k
                                                else if i == k + 1
                                                    it 'should have length %d'.sprintf(5+2*k), -> assert r.length == 5+2*k
                                                else
                                                    it 'should fail', -> assert not r?
                                            else
                                                it 'should fail', -> assert not r?
                

    describe 'with BBCode', ->
        element = (elt) ->
            {
                type: 'element',
                tag: elt.seq[0].groups[1],
                arg: elt.seq[0].groups[2],
                contents: elt.seq[1],
            }

        seq2array = (elt) -> elt.seq

        text = (elt) ->
            {
                type: 'text',
                text: elt.match,
            }

        class BBCodeParser extends Parser
            @define_production('Document',
                @transform(seq2array,
                    @zero_or_more(
                        @alternation(
                            @v('Element'),
                            @v('TagOrText')))))

            @define_production('Element',
                @transform(element,
                    @seq(
                        @re('\\[([A-Za-z]*)(?:=([^\\]]*))?\\]', 'opentag'),
                        @transform(seq2array,
                            @zero_or_more(
                                @alternation(
                                    @v('Element'),
                                    @v('NotSpecificCloseTagOrText', @backref('opentag[1]'))))),
                        @var_re('\\[/\\=opentag[1]\\]'))))

            @define_production('NotSpecificCloseTagOrText',
                @transform(text, @var_re('\\[/(?!\\=arg[0]\\])[^\\]]*\\]|\\[(?:[^/][^\\]]*)?\\]|[^\\[]+')))

            @define_production('TagOrText', @transform(text, @re('\\[[^\\]]*\\]|[^\\[]+')))

        b = new BBCodeParser()

        describe 'basic test case', ->
            r = b.parse('[zoo][/zoo][/i][q][b=1]text[w][a]text2[/a][/b]')
            r_correct = `[ { type: 'element', tag: 'zoo', arg: undefined, contents: [] },
                { type: 'text', text: '[/i]' },
                { type: 'text', text: '[q]' },
                { type: 'element',
                    tag: 'b',
                    arg: '1',
                    contents: 
                      [ { type: 'text', text: 'text' },
                          { type: 'text', text: '[w]' },
                          { type: 'element',
                              tag: 'a',
                              arg: undefined,
                              contents: [ { type: 'text', text: 'text2' } ] } ] } ]`

            it 'should output DOM matching model', ->
                assert deep_equal(r, r_correct)

        describe 'newline', ->
            r = b.parse('[zoo]abc\ndef[/zoo]')
            r_correct = `[ { type: 'element', tag: 'zoo', arg: undefined, contents: [ { type: 'text', text: 'abc\ndef' } ] } ]`

            it 'should be accepted as text', ->
                assert deep_equal(r, r_correct)