note
    description: "Summary description for {JOTTO}."
    author: ""
    date: "$Date$"
    revision: "$Revision$"

class
    JOTTO
create
    make
feature
    secretSet : LINKED_SET[CHARACTER]
    eliminateDigits: LINKED_SET[CHARACTER]
    correctDigits: LINKED_SET[CHARACTER]
feature{ANY}

    make
    do
        create secretSet.make
        create eliminateDigits.make
        create correctDigits.make

    end


    toCharArray(n: STRING): ARRAY[CHARACTER]
    local
        out_array:ARRAY[CHARACTER]
        i:INTEGER
    do
        create out_array.make_filled ('0', 0, n.count - 1)
        from
            i := 1
        until
            i > n.count
        loop
            out_array[i-1] := n.at (i)
            i:= i + 1
        end
        result := out_array
    end

    commonCount(a:STRING; b:STRING):INTEGER
    local
        count,i,j:INTEGER
        aletters: ARRAY[CHARACTER]
        bletters: ARRAY[CHARACTER]
    do
        --change string to array
        aletters := toCharArray(a)
        bletters := toCharArray(b)
        count := 0
        --loop and find if any of the letters from a and b match
        from
            i := 0
        until
            i >= aletters.capacity
        loop
            from
                j := 0
            until
                j >= bletters.capacity
            loop
                if(aletters[i] ~ bletters[j])
                then
                    count := count + 1

                end
            end

        end



    end
    differentDigit(a: STRING ; b: STRING): LINKED_LIST[CHARACTER]
    local
        i,j:INTEGER
        found,exit: BOOLEAN
        differentDigits:LINKED_LIST[CHARACTER]
        aletters: ARRAY[CHARACTER]
        bletters: ARRAY[CHARACTER]
    do
        --change string to array
        create differentDigits.make
        aletters := toCharArray(a)
        bletters := toCharArray(b)
        from
            i := 0
        until
            i >= aletters.capacity or exit
        loop
            from
                j := 0
            until
                j >= bletters.capacity
            loop
                if(aletters[i] ~ bletters[j])
                then
                    found := true
                    exit := true
                end
            end
            if(not found)
            then
                differentDigits.extend(aletters[i])
            end

        end

        result := differentDigits

    end

    getSafeDigits(a: STRING;  elimDig: LINKED_SET[CHARACTER]; correctDig: LINKED_SET[CHARACTER]): LINKED_SET[CHARACTER]
    local
        aletters: ARRAY[CHARACTER]
        safeDigits: LINKED_SET[CHARACTER]
        i:INTEGER
    do
        create safeDigits.make
        aletters := toCharArray(a)

        from
            i := 0
        until
            i >= aletters.capacity
        loop
            if(not elimDig.has (aletters[i]) and not correctDig.has (aletters[i]))
            then
                safeDigits.extend(aletters[i])
            end
        end
        result := safeDigits

    end


    inCommonWithSet(a: STRING; set: LINKED_SET[CHARACTER]): LINKED_SET[CHARACTER]
    local
        aletters: ARRAY[CHARACTER]
        inCommon: LINKED_SET[CHARACTER]
        i:INTEGER
    do
        create inCommon.make
        aletters := toCharArray(a)

        from
            i := 0
        until
            i >= aletters.capacity
        loop
            if(set.has (aletters[i]))
            then
                inCommon.extend(aletters[i])
            end
        end
        result := inCommon

    end

    notInCommonWithSet(a: STRING; set: LINKED_SET[CHARACTER]): LINKED_SET[CHARACTER]
    local
        aletters: ARRAY[CHARACTER]
        notInCommon: LINKED_SET[CHARACTER]
        i:INTEGER
    do
        create notInCommon.make
        aletters := toCharArray(a)

        from
            i := 0
        until
            i >= aletters.capacity
        loop
            if(not set.has (aletters[i]))
            then
                notInCommon.extend(aletters[i])
            end
        end
        result := notInCommon

    end

    numberOfCorrectAndElim(a: STRING ; correct: LINKED_SET[CHARACTER]; elim: LINKED_SET[CHARACTER]): INTEGER
    local
        i,count:INTEGER
        aletters: ARRAY[CHARACTER]
    do
        count :=0
        aletters := toCharArray(a)
        from
            i := 0
        until
            i >= aletters.capacity
        loop
            if(correct.has (aletters[i]) and elim.has (aletters[i]))
            then
                count := count + 1
            end
        end
        result := count

    end

    next_line:STRING
    local
    input: STRING
    do
        io.read_line
        input := io.last_string
        result := input

    end

    correctOrder(userGuessArray: ARRAY[CHARACTER]):BOOLEAN
    local
        count,j:INTEGER
        output:BOOLEAN
    do

        from
            j:=0
        until
            j >= userGuessArray.capacity
        loop
            correctDigits.extend (userGuessArray[j])

        end
        from
            j:= 1
        until
            j > secretSet.count
        loop
            if(secretSet.i_th (j) ~ userGuessArray[j - 1])
            then
                count := count + 1
            end
        end
        if count ~ 3
        then
            output := true
        end
        result := output
    end


    main
    local

        input,key: STRING
        length,i, numCorrectDig,previousHint: INTEGER
        win: BOOLEAN
        secret: STRING--ARRAY[CHARACTER]
        userGuessArray: ARRAY[CHARACTER]
        userGuesses : MY_MAP[STRING, INTEGER]
        userGuesses_iter:MAP_ITERATOR[STRING, INTEGER]
        prevNotCurrent:LINKED_LIST[CHARACTER]
        currentNotPrev:LINKED_LIST[CHARACTER]
        --userGuesses_iter:MAP_ITERATOR[STRING, INTEGER]
    do
        create prevNotCurrent.make
        create currentNotPrev.make
        create userGuesses.make
        numCorrectDig := 0
        --secret := toCharArray("365")
        secret := "365"
        from
            i := 0
        until
            i >= secret.capacity
        loop
            secretSet.extend (secret[i])
            i := i + 1
        end

        print("What's your guess?%N")
        --io.read_line
        --input := io.last_string
        --guess := toCharArray(input)
        --print("guess is : "+ guess[0].out + guess[1].out + guess[2].out+"%N")

        input := next_line
        from

        until
             input ~ "OK" and win
        loop
            userGuessArray := toCharArray (input)
            numCorrectDig := commonCount(input, secret)
            if( numCorrectDig ~ 3)
            then
                win := correctOrder(userGuessArray)
                if win
                then
                    print("YOU WIN! The secret number is: " + input.out + "%N");

                end

            end
            if(not win)
            then
                if(numCorrectDig ~ 0)
                then
                    from
                        i := 0
                    until
                        i >= userGuessArray.capacity
                    loop
                        eliminateDigits.extend (userGuessArray[i])
                    end
                end

                userGuesses_iter := userGuesses.iterator
                from
                until
                    userGuesses_iter.all_done
                loop
                    key:= userGuesses_iter.next
                    previousHint := userGuesses.get (key)
                    if(numCorrectDig ~ previousHint + 1)
                    then
                        prevNotCurrent
                    end
                end

            end



        end
    end

end