import random
import string
import unittest

from TP1.Expression import Expression, Value, Variable, InfixExpression, PrefixExpression
from TP1.main import read_expression

alpha = string.ascii_letters + '_'
alphanum = alpha + string.digits


def generate_alphanum_token(length: int) -> str:
    '''
    Generates a valid alphanumeric token of given length.
    The token consists of `length` alphanumeric characters (including `_`) but does not start with a digit.

    :param length: length of the token to generate
    :return: a valid alphanumeric token of length `length`
    '''

    if length <= 0:
        return random.choice(alpha)
    else:
        return random.choice(alpha) + ''.join(random.choice(alphanum) for i in range(length))


def generate_num_token(length: int) -> str:
    '''
    Generates a valid numeric token of given length.
    The token consists of `length` digits.

    :param length: length of the token to generate
    :return: a valid numeric token of length `length`
    '''

    if length <= 0:
        return '0'
    else:
        return random.choice(string.digits) + ''.join(random.choice(string.digits) for i in range(length))

def generate_random_Value():
    token = generate_num_token(random.randrange(10))
    return Value(token)


def generate_random_Variable():
    token = generate_alphanum_token(random.randrange(10))
    v = Variable(token)
    value = random.randrange(1000)
    v.set_value(value)
    return v

def generate_full_random_Expression(expression_types = [Value, Variable, InfixExpression, PrefixExpression]):

    random_expression = None
    random_type = random.choice(expression_types)

    if random_type == Value:
        random_expression = generate_random_Value()
    elif random_type == Variable:
        random_expression = generate_random_Variable()
    elif random_type == PrefixExpression:
        random_expression = generate_full_random_Expression(expression_types)
        random_expression = PrefixExpression('-', random_expression)
    elif random_type == InfixExpression:
        random_expression1 = generate_full_random_Expression(expression_types)
        random_expression2 = generate_full_random_Expression(expression_types)
        random_expression = InfixExpression(random.choice(['-', '+', '*', '/']), random_expression1, random_expression2)
    else:
        raise RuntimeError("Cette erreur est impossible")

    return random_expression

class FullTest(unittest.TestCase):


    def test_FullWithoutPrefix(self):
        for i in range(1000):
            expression = generate_full_random_Expression([Value, Variable, InfixExpression])
            expression_str = str(expression)

            parsed_expression = read_expression(expression_str)[0]
            parsed_expression_str = str(parsed_expression)
            self.assertEqual(expression_str, parsed_expression_str)

    def test_FullWithPrefix(self):
        for i in range(1000):
            expression = generate_full_random_Expression()
            expression_str = str(expression)

            parsed_expression = read_expression(expression_str)[0]
            parsed_expression_str = str(parsed_expression)
            self.assertEqual(expression_str, parsed_expression_str)

if __name__ == '__main__':
    unittest.main()