import spock.lang.*

class TweakSequenceUtilSpecification extends Specification {


    @Unroll
    @TweakSequence
    def "#iterationCount): sequence using indexReplacements column correctly: #sequence and #indexReplacements = #result"() {

        expect:
            sequence == result

        where:

            result       | sequence                        | indexReplacements
            [ 1, 99, 3 ] | [ 1, 2, 3 ]                     | [ 1: 99 ]
            [ 1, 99, 3 ] | [ range: [ start: 1, end: 3 ] ] | [ 1: 99 ]


    }

    @Unroll
    @TweakSequence
    def "#iterationCount): sequence using indexReplacements column correctly with multiple replacements: #sequence and #indexReplacements = #result"() {

        expect:
            sequence == result

        where:

            result         | sequence                                                           | indexReplacements
            [ 9, 2, 0, 4 ] | [ 1, 2, 3, 4 ]                                                     | [ 0: 9, 2: 0 ]
            [ 9, 2, 0, 4 ] | [ range: [ start: 1, end: 4 ], indexReplacements: [ 0: 9, 2: 0 ] ] | [ : ]
            [ 9, 2, 0, 4 ] | [ sequence: [ 1, 2, 3, 4 ], indexReplacements: [ 0: 9, 2: 0 ] ]    | [ : ]
    }

    @Unroll
    @TweakSequence
    def "#iterationCount): sequence or range with tweaks in map: #sequence = #result"() {

        expect:
            sequence == result

        where:

            result       | sequence
            [ 1, 2, 3 ]  | [ 1, 2, 3 ]
            [ 1, 2, 3 ]  | [ range: [ start: 1, end: 3 ] ]
            [ 1, 99, 3 ] | [ range: [ start: 1, end: 3 ], indexReplacements: [ 1: 99 ] ]
            [ 1, 99, 3 ] | [ sequence: [ 1, 2, 3 ], indexReplacements: [ 1: 99 ] ]


    }

    @Unroll
    @TweakSequence
    def "#iterationCount): sequence #sequence using tweaks column #tweaks correctly results as #result"() {

        expect:
            sequence == result

        where:

            result    | sequence                        | tweaks
            [ 1, 4 ]  | [ 1, 2, 3, 4 ]                  | [ valueExclusions: [ 2, 3 ] ]
            [ 1, 4 ]  | [ range: [ start: 1, end: 4 ] ] | [ valueExclusions: [ 2, 3 ] ]
            [ 99, 4 ] | [ 1, 2, 3, 4 ]                  | [ valueExclusions: [ 2, 3 ], indexReplacements: [ 0: 99 ] ]

    }

    @Unroll
    @TweakSequence( tweaksParameterName = "otherTweaks" )
    def "#iterationCount): alternate tweaks column: sequence using tweak column correctly results as #result"() {

        expect:
            sequence == result

        where:

            result   | sequence                        | otherTweaks
            [ 1, 3 ] | [ 1, 2, 3 ]                     | [ valueExclusions: [ 2 ] ]
            [ 1, 3 ] | [ range: [ start: 1, end: 3 ] ] | [ valueExclusions: [ 2 ] ]


    }

    @Unroll
    @TweakSequence( sequenceParameterName = "A" )
    def "#iterationCount): alternate sequence name: sequence #A embedded in map correctly results as #result"() {

        expect:
            A == result

        where:

            result       | A
            [ 1, 2, 3 ]  | [ 1, 2, 3 ]
            [ 1, 2, 3 ]  | [ A: [ 1, 2, 3 ] ]
            [ 1, 99, 3 ] | [ A: [ 1, 2, 3 ], indexReplacements: [ 1: 99 ] ]

    }

    @TweaksSequence
    static List addNumberToSequence( List inputSequence, int numberToAdd ) {
        return inputSequence.stream().mapToInt { i -> i + numberToAdd }.toArray()
    }

    @TweaksSequence
    static List subtractNumberFromSequence( List inputSequence, int numberToSubtract ) {
        return inputSequence.stream().mapToInt { i -> i - numberToSubtract }.toArray()
    }

    @TweaksSequence
    static List reverseSequence( List inputSequence, boolean whetherToReverse ) {
        if ( !whetherToReverse ) return inputSequence

        return new LinkedList( inputSequence ).descendingIterator().toList()
    }

    @Unroll
    @TweakSequence
    def "#iterationCount): added TweakFunctions are used correctly: #sequence"() {

        expect:
            sequence == result
        where:
            result      | sequence
            [ 1, 2, 3 ] | [ 1, 2, 3 ]
            [ 1, 2, 3 ] | [ sequence: [ 1, 2, 3 ] ]
            [ 2, 3, 4 ] | [ sequence: [ 1, 2, 3 ], addNumberToSequence: 1 ]
            [ 0, 1, 2 ] | [ sequence: [ 1, 2, 3 ], subtractNumberFromSequence: 1 ]
            [ 1, 2, 3 ] | [ sequence: [ 1, 2, 3 ], reverseSequence: false ]
            [ 3, 2, 1 ] | [ sequence: [ 1, 2, 3 ], reverseSequence: true ]

    }

}