# This is the template for the InnoDrive e2e and domain and computation test cases.

import pytest
import json

from httpx import Client

my_spec = {
    "budget_minute_price": 17,
    "luxury_minute_price": 37,
    "budget_km_price": 11,
    "deviation": 0.14,
    "inno_discount": 0.06
}

type_cases = ['budget', 'luxury', 'string']
plan_cases = ['fixed_price', 'minute', 'string']
distance_cases = [-1, 0, 10]
inno_discount = ['yes', 'no', 'string']
time_cases = [-1, 0, 10]


@pytest.fixture(scope="module")
def test_app():
    client = Client(base_url="https://instructors.pg.innopolis.university/innodrive")
    yield client


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
def test_spec(test_app, email):
    response = test_app.get("/spec/" + email)
    assert response.status_code == 200


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
@pytest.mark.parametrize(
    "type, plan, distance, planned_distance, time, inno_discount, expected_code",
    [
        # Test case 1: Budget, fixed_price, distance = 10, time = 10, with discount
        (type_cases[0], plan_cases[0], distance_cases[2], 5, time_cases[2], inno_discount[0], 200),
        # Test case 2: Budget, minute, distance = 10, time = 10, with discount
        (type_cases[0], plan_cases[1], distance_cases[2], 10, time_cases[2], inno_discount[0], 200),
        # Test case 3: Budget, minute, distance = -1, time = 10, with discount
        (type_cases[0], plan_cases[1], distance_cases[0], 10, time_cases[2], inno_discount[0], 406),
        # Test case 4: Luxury, minute, distance = 10, time = 10, with discount
        (type_cases[1], plan_cases[1], distance_cases[2], 10, time_cases[2], inno_discount[0], 200),
        # Test case 5: Budget, fixed_price, distance = 10, time = 10, with discount
        (type_cases[0], plan_cases[0], distance_cases[2], 15, time_cases[2], inno_discount[0], 200),
    ]
)
def test_distance(test_app, email, type, plan, distance, planned_distance, time, inno_discount, expected_code):
    data = {
        "type": type,
        "plan": plan,
        "distance": distance,
        "planned_distance": planned_distance,
        "time": time,
        "planned_time": time,
        "inno_discount": inno_discount
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.status_code == expected_code


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
@pytest.mark.parametrize(
    "ride_type, expected_output",
    [
     # Test case 1: Budget
     (type_cases[0], 200),
     # Test case 2: Luxury
     (type_cases[1], 200),
     # Test case 3: nonsense
     (type_cases[2], 406),
    ]
)
def test_ride_type(test_app, email, ride_type, expected_output):
    # gives 200 on nonsense for ride type
    data = {
        "type": ride_type,
        "plan": "fixed_price",
        "distance": 10,
        "planned_distance": 10,
        "time": 10,
        "planned_time": 10,
        "inno_discount": "no"
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.status_code == expected_output


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
@pytest.mark.parametrize(
    "plan_type, expected_output",
    [
     # Test case 1: Minute
     (plan_cases[0], 200),
     # Test case 2: Fixed
     (plan_cases[1], 200),
     # Test case 3: nonsense
     (plan_cases[2], 406),
    ]
)
def test_ride_plan(test_app, email, plan_type, expected_output):
    data = {
        "type": "budget",
        "plan": plan_type,
        "distance": 10,
        "planned_distance": 10,
        "time": 10,
        "planned_time": 10,
        "inno_discount": "no"
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.status_code == expected_output

@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
@pytest.mark.parametrize(
    "discount, expected_output",
    [
        # Test case 1: Minute
        (inno_discount[0], 200),
        # Test case 2: Fixed
        (inno_discount[1], 200),
        # Test case 3: nonsense
        (inno_discount[2], 406),
    ]
)
def test_discount(test_app, email, discount, expected_output):
    # gives 200 on nonsense for discount
    data = {
        "type": "budget",
        "plan": "minute",
        "distance": 10,
        "planned_distance": 10,
        "time": 10,
        "planned_time": 10,
        "inno_discount": discount
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.status_code == expected_output


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
@pytest.mark.parametrize(
    "time, expected_output",
    [
        # Test case 1: Minute
        (time_cases[0], 406),
        # Test case 2: Fixed
        (time_cases[1], 406),
        # Test case 3: nonsense
        (time_cases[2], 200),
    ]
)
def test_time(test_app, email, time, expected_output):
    data = {
        "type": "budget",
        "plan": "minute",
        "distance": 10,
        "planned_distance": 10,
        "time": time,
        "planned_time": time,
        "inno_discount": "no"
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.status_code == expected_output


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
@pytest.mark.parametrize(
    "ride_type, plan_type, expected_output",
    [
        # Test case 1: Budget + minute
        (type_cases[0], plan_cases[1], 200),
        # Test case 2: Budget + fixed
        (type_cases[0], plan_cases[0], 200),
        # Test case 3: Luxury + minute
        (type_cases[1], plan_cases[1], 200),
        # Test case 4: Luxury + fixed
        (type_cases[1], plan_cases[0], 406),
    ]
)
def test_type_plan(test_app, email, ride_type, plan_type, expected_output):
    #Luxury + fixed gives 200 - error
    data = {
        "type": ride_type,
        "plan": plan_type,
        "distance": 10,
        "planned_distance": 10,
        "time": 10,
        "planned_time": 10,
        "inno_discount": "no"
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.status_code == expected_output


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
def test_type_budget_min_computational_ok(test_app, email):
    data = {
        "type": type_cases[0],
        "plan": plan_cases[1],
        "distance": distance_cases[2],
        "planned_distance": distance_cases[2],
        "time": time_cases[2],
        "planned_time": time_cases[2],
        "inno_discount": inno_discount[1]
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.json()['price'] == my_spec["budget_minute_price"] * time_cases[2]


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
def test_type_budget_km_computational_ok(test_app, email):
    data = {
        "type": type_cases[0],
        "plan": plan_cases[0],
        "distance": distance_cases[2],
        "planned_distance": distance_cases[2],
        "time": time_cases[2],
        "planned_time": time_cases[2],
        "inno_discount": inno_discount[1]
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.json()['price'] == my_spec["budget_km_price"] * distance_cases[2]


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
def test_type_luxury_min_computational_err(test_app, email):
    # computational Error => 481 got, but require 370
    data = {
        "type": type_cases[1],
        "plan": plan_cases[1],
        "distance": distance_cases[2],
        "planned_distance": distance_cases[2],
        "time": time_cases[2],
        "planned_time": time_cases[2],
        "inno_discount": inno_discount[1]
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.json()['price'] == my_spec["luxury_minute_price"] * time_cases[2]


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
def test_type_luxury_min_deviation_err(test_app, email):
    # computational Error => 481 got, but max price with deviation is 421.8
    data = {
        "type": type_cases[1],
        "plan": plan_cases[1],
        "distance": distance_cases[2],
        "planned_distance": distance_cases[2],
        "time": time_cases[2],
        "planned_time": time_cases[2],
        "inno_discount": inno_discount[1]
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.json()['price'] == my_spec["luxury_minute_price"] * time_cases[2] * (1+my_spec["deviation"])


@pytest.mark.parametrize("email", ["m.matantsev@innopolis.university"])
def test_type_luxury_discount_err(test_app, email):
    # discount is not being applied - unreal to calculate it
    data = {
        "type": type_cases[0],
        "plan": plan_cases[0],
        "distance": distance_cases[2],
        "planned_distance": distance_cases[2],
        "time": time_cases[2],
        "planned_time": time_cases[2],
        "inno_discount": inno_discount[0]
    }
    response = test_app.post("/price/" + email, content=json.dumps(data))
    assert response.json()['price'] == my_spec["budget_km_price"] * distance_cases[2] * (1 - my_spec["inno_discount"])