import pytest

from ..helpers import Suite
from ..constants import ALL_INT_TYPES, ALL_FLOAT_TYPES, COMPLETE_INT_TYPES, TYPE_MAP

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ALL_INT_TYPES)
def test_expr_constant_int(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 13
"""

    result = Suite(code_py).run_code()

    assert 13 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ALL_FLOAT_TYPES)
def test_expr_constant_float(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 32.125
"""

    result = Suite(code_py).run_code()

    assert 32.125 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ALL_INT_TYPES)
def test_module_constant_int(type_):
    code_py = f"""
CONSTANT: {type_} = 13

@exported
def testEntry() -> {type_}:
    return CONSTANT
"""

    result = Suite(code_py).run_code()

    assert 13 == result.returned_value

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ALL_FLOAT_TYPES)
def test_module_constant_float(type_):
    code_py = f"""
CONSTANT: {type_} = 32.125

@exported
def testEntry() -> {type_}:
    return CONSTANT
"""

    result = Suite(code_py).run_code()

    assert 32.125 == result.returned_value

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ['u32', 'u64']) # FIXME: Support u8, requires an extra AND operation
def test_logical_left_shift(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 10 << 3
"""

    result = Suite(code_py).run_code()

    assert 80 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ['u32', 'u64'])
def test_logical_right_shift_left_bit_zero(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 10 >> 3
"""

    result = Suite(code_py).run_code()

    assert 1 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
def test_logical_right_shift_left_bit_one():
    code_py = """
@exported
def testEntry() -> u32:
    return 4294967295 >> 16
"""

    result = Suite(code_py).run_code()

    assert 0xFFFF == result.returned_value

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ['u8', 'u32', 'u64'])
def test_bitwise_or(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 10 | 3
"""

    result = Suite(code_py).run_code()

    assert 11 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ['u8', 'u32', 'u64'])
def test_bitwise_xor(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 10 ^ 3
"""

    result = Suite(code_py).run_code()

    assert 9 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ['u8', 'u32', 'u64'])
def test_bitwise_and(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 10 & 3
"""

    result = Suite(code_py).run_code()

    assert 2 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', COMPLETE_INT_TYPES)
def test_addition_int(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 10 + 3
"""

    result = Suite(code_py).run_code()

    assert 13 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ALL_FLOAT_TYPES)
def test_addition_float(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 32.0 + 0.125
"""

    result = Suite(code_py).run_code()

    assert 32.125 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', COMPLETE_INT_TYPES)
def test_subtraction_int(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 10 - 3
"""

    result = Suite(code_py).run_code()

    assert 7 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ALL_FLOAT_TYPES)
def test_subtraction_float(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return 100.0 - 67.875
"""

    result = Suite(code_py).run_code()

    assert 32.125 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

# TODO: Multiplication
# TODO: Division

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ['f32', 'f64'])
def test_buildins_sqrt(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return sqrt(25.0)
"""

    result = Suite(code_py).run_code()

    assert 5 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', TYPE_MAP.keys())
def test_function_argument(type_):
    code_py = f"""
@exported
def testEntry(a: {type_}) -> {type_}:
    return a
"""

    result = Suite(code_py).run_code(125)

    assert 125 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.skip('TODO')
def test_explicit_positive_number():
    code_py = """
@exported
def testEntry() -> i32:
    return +523
"""

    result = Suite(code_py).run_code()

    assert 523 == result.returned_value

@pytest.mark.integration_test
@pytest.mark.skip('TODO')
def test_explicit_negative_number():
    code_py = """
@exported
def testEntry() -> i32:
    return -19
"""

    result = Suite(code_py).run_code()

    assert -19 == result.returned_value

@pytest.mark.integration_test
def test_call_no_args():
    code_py = """
def helper() -> i32:
    return 19

@exported
def testEntry() -> i32:
    return helper()
"""

    result = Suite(code_py).run_code()

    assert 19 == result.returned_value

@pytest.mark.integration_test
def test_call_pre_defined():
    code_py = """
def helper(left: i32, right: i32) -> i32:
    return left + right

@exported
def testEntry() -> i32:
    return helper(10, 3)
"""

    result = Suite(code_py).run_code()

    assert 13 == result.returned_value

@pytest.mark.integration_test
def test_call_post_defined():
    code_py = """
@exported
def testEntry() -> i32:
    return helper(10, 3)

def helper(left: i32, right: i32) -> i32:
    return left - right
"""

    result = Suite(code_py).run_code()

    assert 7 == result.returned_value

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', COMPLETE_INT_TYPES)
def test_call_with_expression_int(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return helper(10 + 20, 3 + 5)

def helper(left: {type_}, right: {type_}) -> {type_}:
    return left - right
"""

    result = Suite(code_py).run_code()

    assert 22 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)

@pytest.mark.integration_test
@pytest.mark.parametrize('type_', ALL_FLOAT_TYPES)
def test_call_with_expression_float(type_):
    code_py = f"""
@exported
def testEntry() -> {type_}:
    return helper(10.078125 + 90.046875, 63.0 + 5.0)

def helper(left: {type_}, right: {type_}) -> {type_}:
    return left - right
"""

    result = Suite(code_py).run_code()

    assert 32.125 == result.returned_value
    assert TYPE_MAP[type_] == type(result.returned_value)