import { Aligner } from '../src/Aligner'
import { SeqNode, Sequence } from '../src/SeqNode'
import { AlignType } from '../src/types'

describe('Aligner', function() {
    it('creates an Aligner object', function() { 
        const aligner = new Aligner<string>(AlignType.Global)
        expect(aligner.alignType).toBe(AlignType.Global)
        expect(aligner.seq1).toStrictEqual([])
        expect(aligner.seq2).toStrictEqual([])
    })

    it('aligns identical sequences', function() {
        const aligner = new Aligner<string>(AlignType.Global)

        const nodes1: Sequence<string> = [
            new SeqNode('n1', [40]),
            new SeqNode('n2', [45]),
            new SeqNode('n3', [50]),
            new SeqNode('n4', [55])
        ]

        aligner.align(nodes1, nodes1, {
            gapOpen: -5,
            gapExt: -1
        })

        const result = aligner.retrieveAlignments()
        expect(result).toBeDefined()
        expect(result.score).toEqual(4)
        expect(result.paths).toStrictEqual([ [ ['n4', 'n4'], ['n3', 'n3'], ['n2', 'n2'], ['n1', 'n1'] ] ])
    })

    it('aligns non-identical sequence with a gap', function() {
        const aligner = new Aligner<string>(AlignType.Global)

        const nodes1: Sequence<string> = [
            new SeqNode('n1', [40]),
            new SeqNode('n2', [45]),
            new SeqNode('n3', [50]),
            new SeqNode('n4', [55])
        ]

        const nodes2: Sequence<string> = [
            new SeqNode('n1', [40]),
            new SeqNode('n3', [50]),
            new SeqNode('n4', [55])
        ]

        aligner.align(nodes1, nodes2, {
            gapOpen: -5,
            gapExt: -1
        })

        const result = aligner.retrieveAlignments()
        expect(result).toBeDefined()
        expect(result.score).toEqual(-3) // correct?
        expect(result.paths).toStrictEqual([ [ ['n4', 'n4'], ['n3', 'n3'], ['n2', '-'], ['n1', 'n1'] ] ])
    })

    it('aligns almost identical sequences', function() {
        const aligner = new Aligner<string>(AlignType.Global)

        const nodes1: Sequence<string> = [
            new SeqNode('n1', [40, 0.2]),
            new SeqNode('n2', [45, 0.25]),
            new SeqNode('n3', [50, 0.15]),
            new SeqNode('n4', [55, 0.4])
        ]

        const nodes2: Sequence<string> = [
            new SeqNode('n1', [41, 0.21]),
            new SeqNode('n3', [50, 0.24, ]),
            new SeqNode('n4', [54, 0.4])
        ]

        aligner.align(nodes1, nodes2, {
            gapOpen: -5,
            gapExt: -1
        })

        const result = aligner.retrieveAlignments()
        expect(result).toBeDefined()
    })

    it('aligns more complex sequence nodes', function () {
        const aligner = new Aligner<string>(AlignType.Global)

        const charCodesFor = (str: string): number[]  => [...str].map((char: string) => char.charCodeAt(0))

        const nodes1: Sequence<string> = [
            new SeqNode('1_pessubpunctis',  charCodesFor('efed')),
            new SeqNode('2_climacus',       charCodesFor('gfe')),
            new SeqNode('3_pes',            charCodesFor('de')),
            new SeqNode('4_punctum',        charCodesFor('g')),
            new SeqNode('5_punctum',        charCodesFor('a')),
            new SeqNode('6_virga',          charCodesFor('c')),
        ]

        const nodes2: Sequence<string> = [
            new SeqNode('1_pessubpunctis',  charCodesFor('efed')),
            new SeqNode('2_climacus',       charCodesFor('gfe')),
            new SeqNode('3_pes',            charCodesFor('de')),
            new SeqNode('4_punctum',        charCodesFor('g')),
            new SeqNode('5_punctum',        charCodesFor('g')),
            new SeqNode('6_punctum',        charCodesFor('a')),
            new SeqNode('7_virga',          charCodesFor('c')),
        ]

        aligner.align(nodes1, nodes2, {
            gapOpen: -5,
            gapExt: -1
        })

        const result = aligner.retrieveAlignments()
        expect(result).toBeDefined()
    })

    it('throws when trying to receive results without aligning first', function() {
        const aligner = new Aligner<string>(AlignType.Global)
        expect(aligner.retrieveAlignments).toThrow()
    }) 
})

/*
describe('TemporalAligner', function () {
    it('creates an TemporalAligner object', function() { 
        const aligner = new TemporalAligner<string>(AlignType.Global)
        expect(aligner.alignType).toBe(AlignType.Global)
        expect(aligner.seq1).toStrictEqual([])
        expect(aligner.seq2).toStrictEqual([])
    })

    it('aligns identical sequences', function() {
        const aligner = new TemporalAligner<string>(AlignType.Global)

        const nodes1: Sequence<string> = [
            new SeqNode('n1', [40], 5),
            new SeqNode('n2', [45], 5),
            new SeqNode('n3', [50], 5),
            new SeqNode('n4', [55], 5)
        ]

        aligner.align(nodes1, nodes1, {
            gapOpen: -5,
            gapExt: undefined
        })

        const result = aligner.retrieveAlignments()
        expect(result).toBeDefined()
        //expect(result.score).toEqual(4)
        expect(result.paths).toStrictEqual([ [ ['n4', 'n4'], ['n3', 'n3'], ['n2', 'n2'], ['n1', 'n1'] ] ])
    })

    it('aligns sequence with two events happening at the same time', function() {
        const aligner = new TemporalAligner<string>(AlignType.Global)

        const nodes1: Sequence<string> = [
            new SeqNode('n1', [40], 5),
            new SeqNode('n2', [45], 0),
            new SeqNode('n3', [50], 5),
            new SeqNode('n4', [55], 5)
        ]

        const nodes2: Sequence<string> = [
            new SeqNode('n1', [45], 5),
            new SeqNode('n2', [40], 0),
            new SeqNode('n3', [50], 5),
            new SeqNode('n4', [55], 5)
        ]

        aligner.align(nodes1, nodes2, {
            gapOpen: -1,
            gapExt: undefined
        })

        const result = aligner.retrieveAlignments()
        expect(result).toBeDefined()
        //expect(result.score).toEqual(-3) // correct?
        expect(result.paths).toStrictEqual([ [ ['n4', 'n4'], ['n3', 'n3'], ['n2', 'n1'], ['n1', 'n2'] ] ])
    })

    it('aligns temporal sequences', function() {
        const aligner = new TemporalAligner<string>(AlignType.Global)

        const nodes1: Sequence<string> = [
            new SeqNode('n1', [40], 3),
            new SeqNode('n4', [40], 1)
        ]

        const nodes2: Sequence<string> = [
            new SeqNode('n1', [40], 1),
            new SeqNode('n2', [20], 1),
            new SeqNode('n3', [20], 1),
            new SeqNode('n4', [40], 1)
        ]

        aligner.align(nodes1, nodes2, {
            gapOpen: -1,
            gapExt: undefined
        })

        const result = aligner.retrieveAlignments()
        expect(result).toBeDefined()
        //expect(result.score).toEqual(-3) // correct?
        expect(result.paths).toStrictEqual([ [ ['n4', 'n4'], ['-', 'n3'], ['-', 'n2'], ['n1', 'n1'] ], [] ])
    })

})
*/