from random import randint

"""
plays a single game of Master Mind, where the
computer picks a number and the human guesses
"""
def play_computer_picks():
    number_of_guesses = 0
    pick = pick_number()

    while True:
        guess = get_guess_from_user()
        number_of_guesses = number_of_guesses + 1
        if pick == guess:
            print "Congratulations!!! You found the answer in", number_of_guesses, "times."
            break

        if pick.lower() == "q":
            print "better luck next time!"
            print "the answer was", pick
            break
        
        feedback = compute_answer(pick, guess)
        print "Feedback:", feedback

"""
returns a random string, containing four digits
between 1 and 6
"""
def pick_number():
    pick = ""

    for i in range(0, 4):
        digit = randint(1, 6)
        pick = pick + str(digit)

    return pick

"""
returns a string entered by the user, containing
four digits between 1 and 6. We also allow a "q"
or "Q". Anything else is rejected and we ask the
user to try again.
"""
def get_guess_from_user():
    while True:
        guess = raw_input("enter your guess: ")
        if (guess.lower() == "q"):
            return guess

        if (is_valid_guess(guess)):
            return guess

        print guess, "is not a valid guess, try again."

"""
returns True if the guess is a four-digit string
containing digits from 1 to 6.
"""
def is_valid_guess(guess):
    if (len(guess) != 4):
        return False

    for character in guess:
        if not(character in "123456"):
            return False

    return True


"""
inputs:
- guess (what the player has guessed)
- pick (the original number that was picked)

output:
- a string of o's and x's that follows the rules of Master Mind
"""
def compute_answer(guess, pick):
    os = compute_os(guess, pick)
    xs = compute_xs(guess, pick)
    answer = os + xs
    return answer


"""
inputs:
- guess (what the player has guessed)
- pick (the original number that was picked)

output:
- a string of o's (as many as the positions that have the same number)
"""
def compute_os(guess, pick):
    answer = ""
    for i in range(0, 4):
        if (guess[i] == pick[i]):
            answer = answer + "o"

    return answer

def compute_os_2(guess, pick):
    if (len(guess) == 0):
        return ""
    
    first_answer = ""
    if (guess[0] == pick[0]):
        first_answer = "o"

    rest_of_answer = compute_os_2(guess[1:], pick[1:])

    answer = first_answer + rest_of_answer
    return answer


def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

"""
inputs:
- guess (what the player has guessed)
- pick (the original number that was picked)

output:
- a string of x's 
"""
def compute_xs(guess, pick):
    [guess, pick] = remove_identical_positions(guess, pick)

    guess_list = list(guess)
    pick_list = list(pick)

    answer = ""
    for g in guess_list:
        for p in pick_list:
            if (p == g):
                answer = answer + "x"
                position = pick_list.index(p)
                del(pick_list[position])
                break

    return answer



def remove_identical_positions(guess, pick):
    new_guess = ""
    new_pick = ""

    for i in range(0, len(guess)):
        if (guess[i] != pick[i]):
            new_guess = new_guess + guess[i]
            new_pick = new_pick + pick[i]

    return [new_guess, new_pick]


"""
plays a game where the human picks and the computer guesses.
No arguments, no return values
"""
def play_human_picks():
    number_of_guesses = 0
    guess_list = []
    feedback_list = []

    guess = first_computer_guess()
    while True:
        number_of_guesses = number_of_guesses + 1
        feedback = provide_feedback(guess)
        
        if (feedback == "oooo"):
            print("I'm awesome, got it in", number_of_guesses, "guesses!")
            break

        guess_list.append(guess)
        feedback_list.append(feedback)
        guess = computer_guess(guess_list, feedback_list)
    

"""
takes no input, returns a random guess as an output.
"""
def first_computer_guess():
    result = pick_number()
    return result

"""
its input is a list of the first i guesses that the
computer made, and the first i feedbacks that the user
provided
the output is the next guess by the computer
"""
def computer_guess(guess_list, feedback_list):
    number_of_guesses = 0
    pick = pick_number()

    while True:
        guess = get_guess_from_user()
        number_of_guesses = number_of_guesses + 1
        if pick == guess:
            print "Congratulations!!! You found the answer in", number_of_guesses, "times."
            break

        if pick.lower() == "q":
            print "better luck next time!"
            print "the answer was", pick
            break
        
        feedback = compute_answer(pick, guess)

"""
asks the user to provide feedback on the last answer.
returns the user's feedback.
"""
def provide_feedback(computer_guess):
    while (True):
        feedback = raw_input("enter feedback for " + computer_guess + ":");
        check = check_feedback(feedback)
        if (check == False):
            print("Invalid feedback:", feedback)
        else:
            break

    return feedback

"""
input: feedback that the user just provided
output: True if the feedback is a legal feedback.
Note: the computer has no way of knowing if
the feedback is actually correct.
"""
def check_feedback(feedback):
    # length cannot be more than four
    if (len(feedback) > 4):
        return False

    # should only have os and xs
    check = os_and_xs_check(feedback)
    if (check == False):
        return False

    # the os should come before the xs
    check = os_before_xs_check(feedback)
    if (check == False):
        return False

    return True

"""
input: feedback provided by the user
output: True if feedback contains only os and xs
def os_and_xs_check(feedback)
"""
def check_os_and_xs(feedback):
    for i in feedback:
        if not(i in "ox"):
            return False

    return True

"""
input: feedback provided by the user
output: True if feedback if os show up only before xs
"""
def check_os_before_xs(feedback):
    sorted_feedback = sort_string(feedback)
    if (feedback == sorted_feedback):
        return True
    else:
        return False

"""
input: a string s
output: a sorted version of the input string
"""
def sort_string(s):
    s_list = list(s)
    sorted_list = s_list.sort()
    result = list_to_string(sorted_list)
    return result

def list_to_string(l)
    result = ""
    for i in l:
        result = result + i

    return result