import json
from pathlib import Path
from unittest.mock import patch

import pytest
from aiohttp import ClientSession
from gestion_sport_connector import GestionSportsConnector

from tests.unit_tests import responses


def test_urls(connector, club):
    base_url = "https://ptf1.com"

    assert connector.landing_url == f"{base_url}/landing.html"
    assert connector.login_url == f"{base_url}/login.html"
    assert connector.booking_url == f"{base_url}/booking.html"
    assert connector.user_bookings_url == f"{base_url}/user_bookings.html"
    assert connector.booking_cancellation_url == f"{base_url}/cancel.html"
    assert connector.tournaments_sessions_url == f"{base_url}/tournaments_sessions.php"
    assert connector.tournaments_list_url == f"{base_url}/tournaments_list.html?event="


@patch("config.get_resources_folder")
def test_urls_payload_templates(mock_resources, club):
    path_to_resources = Path("some/path/to/resource")
    mock_resources.return_value = path_to_resources

    connector = GestionSportsConnector(club)

    assert (
        connector.login_template
        == path_to_resources / "gestion-sports/login-payload.txt"
    )
    assert (
        connector.booking_template
        == path_to_resources / "gestion-sports/booking-payload.txt"
    )
    assert (
        connector.user_bookings_template
        == path_to_resources / "gestion-sports/user-bookings-payload.txt"
    )
    assert (
        connector.booking_cancel_template
        == path_to_resources / "gestion-sports/booking-cancellation-payload.txt"
    )
    assert (
        connector.tournaments_sessions_template
        == path_to_resources / "gestion-sports/tournament-sessions-payload.txt"
    )


@pytest.mark.asyncio
async def test_landing_page(aioresponses, connector, landing_response):
    responses.make_landing_request_success(aioresponses, connector, landing_response)

    async with ClientSession() as session:
        response = await connector.land(session)

    assert response.status == 200
    assert response.cookies.get("PHPSESSID").value == "987512"
    assert await response.text() == landing_response


@pytest.mark.asyncio
async def test_login_success(aioresponses, connector, user, login_success_response):
    responses.make_login_request_success(
        aioresponses, connector, login_success_response
    )

    async with ClientSession() as session:
        response = await connector.login(session, user)

    assert response.status == 200
    assert response.cookies.get("COOK_COMPTE").value == "e2be1"
    assert response.cookies.get("COOK_ID_CLUB").value == "22"
    assert response.cookies.get("COOK_ID_USER").value == "666"
    assert await response.json() == login_success_response


@pytest.mark.asyncio
async def test_login_failure(aioresponses, connector, user, login_failure_response):
    responses.make_login_request_fail(aioresponses, connector, login_failure_response)

    async with ClientSession() as session:
        response = await connector.login(session, user)

    assert response.status == 200
    assert len(response.cookies) == 0
    assert await response.json() == login_failure_response


def test_get_booked_court(connector, booked_courts_response):
    booked_court = connector.get_booked_court(booked_courts_response, "Sport1")
    assert booked_court.number == 3


@pytest.mark.asyncio
async def test_get_ongoing_bookings(
    aioresponses,
    connector,
    user,
    user_bookings_get_response,
    user_bookings_list,
):
    responses.set_ongoing_bookings_response(
        aioresponses, connector, user_bookings_get_response, user_bookings_list
    )

    async with ClientSession() as session:
        bookings = await connector.get_ongoing_bookings(session)

    assert len(bookings) == 2


@pytest.mark.asyncio
async def test_cancellation_request(
    aioresponses, connector, user_bookings_get_response, cancellation_response
):
    responses.set_hash_response(aioresponses, connector, user_bookings_get_response)
    responses.set_cancellation_response(aioresponses, connector, cancellation_response)

    async with ClientSession() as session:
        response = await connector.cancel_booking_id(session, 123)

    assert await response.json() == cancellation_response


@pytest.mark.asyncio
async def test_cancel_booking_success(
    aioresponses,
    connector,
    user,
    cancellation_success_booking_filter,
    cancellation_success_from_start,
):
    responses.set_full_cancellation_responses(
        aioresponses, connector, cancellation_success_from_start
    )

    async with ClientSession() as session:
        response = await connector.cancel_booking(
            session, cancellation_success_booking_filter
        )

    assert await response.json() == cancellation_success_from_start[4]


@pytest.mark.asyncio
async def test_tournament_sessions(
    aioresponses, connector, user, tournament_sessions_json
):
    responses.set_tournaments_sessions_response(
        aioresponses, connector, tournament_sessions_json
    )
    async with ClientSession() as session:
        response = await connector.send_tournaments_sessions_request(session)

    assert response.status == 200

    all_sessions = json.loads(await response.text())
    sessions = all_sessions.get("Inscription tournois:school-outline")
    assert len(sessions) == 1


@pytest.mark.asyncio
async def test_send_tournaments_request(
    aioresponses, connector, user, tournaments_html
):
    tournament_session_id = "255"
    responses.set_tournaments_list_response(
        aioresponses, connector, tournament_session_id, tournaments_html
    )
    async with ClientSession() as session:
        response = await connector.send_tournaments_request(
            session, tournament_session_id
        )
        assert "<span class='nb_place_libre'>Complet</span>" in await response.text()