import json
import pytest

# from django.contrib.auth.models import User
from django.urls import reverse

from rich.pretty import pprint

from bs4 import BeautifulSoup

from django.contrib.auth.models import Group

from rapids.views import GenericExamViews as RapidExamViews
from rapids.views import GenericExamViews as LongExamViews
from sbas.views import GenericExamViews as SbaExamViews
from longs.views import GenericExamViews as LongExamViews
from physics.views import GenericExamViews as PhysicExamViews
from anatomy.views import GenericExamViews as AnatomyExamViews

APP_NAMES = ("rapids", "anatomy", "longs", "physics", "sbas")

JSON_APPS = ("rapids", "anatomy", "longs")

EXAM_VIEWS = (
    RapidExamViews,
    LongExamViews,
    SbaExamViews,
    PhysicExamViews,
    AnatomyExamViews,
)

JSON_VIEWS = (
    RapidExamViews,
    LongExamViews,
    AnatomyExamViews,
)


@pytest.fixture
def create_superuser(db, django_user_model):
    return django_user_model.objects.create_superuser(
        "admin", "ross@xkjq.uk", "adminpassword"
    )

@pytest.fixture
def create_cid_manager(db, django_user_model):
    user = django_user_model.objects.create_user(
        "cid_user", "cid@user.com", "password1234"
    )
    g = Group.objects.create(name="cid_user_manager")
    g.save()
    user.groups.add(g)
    return user


@pytest.fixture(params=EXAM_VIEWS)
def set_up_exams(request, django_user_model, create_superuser):
    basic_user = django_user_model.objects.create_user(
        "basicuser", "user@user.net", "pass2"
    )

    e1 = request.param.Exam.objects.create(name="test exam", exam_mode=True)
    e = request.param.Exam.objects.create(name="test exam basic user", exam_mode=True)
    e.author.add(basic_user)
    return request.param


# We only test JSON functionality with this so limit the views
@pytest.fixture(params=JSON_VIEWS)
def set_up_packets(request):
    e = request.param.Exam.objects.create(name="test packet", exam_mode=False, active=True)
    return request.param


# @pytest.fixture
# def create_exam(db):
#    return Exam.objects.create(name="test exam", exam_mode=True)

# Very basic tests, make sure we can hit key urls without error

def test_index2(client, set_up_exams):
    client.login(username="admin", password="adminpassword")
    response = client.get(reverse(f"{set_up_exams.app_name}:index"))
    assert response.status_code == 200

    assert (
        BeautifulSoup(response.content, "html.parser")
        .find("h4", {"class": "exam-number-title"})
        .getText()
        == "2 exams found."
    )


def test_packet_json_access(db, client, set_up_packets):
    """
    Simple test to check that json is retrievable from non exam mode packets
    """
    if set_up_packets.app_name in JSON_APPS:
        exam_id = set_up_packets.Exam.objects.get(name="test packet").pk

        response = client.get(reverse(f"{set_up_packets.app_name}:exam_json", args=[exam_id]))
        assert response.status_code == 200

        exam_json = json.loads(response.content)

        # Remove the s at the end of the app name
        # TODO: unify this....
        #assert exam_json["eid"] == f"{set_up_packets.app_name/{exam_id}"
        assert exam_json["eid"].split("/")[-1] == f"{exam_id}"
        print(exam_json)
        assert exam_json["exam_mode"] == False
        assert exam_json["exam_name"] == "test packet"
        assert len(exam_json["questions"]) == 0

def test_overview(client, set_up_exams):
    client.login(username="admin", password="adminpassword")
    
    e1 = set_up_exams.Exam.objects.get(name="test exam").pk
    e2 = set_up_exams.Exam.objects.get(name="test exam basic user").pk

    response = client.get(reverse(f"{set_up_exams.app_name}:exam_overview", args=[e1]))
    assert response.status_code == 200

    response = client.get(reverse(f"{set_up_exams.app_name}:exam_overview", args=[e2]))
    assert response.status_code == 200

    client.login(username="basicuser", password="pass2")
    response = client.get(reverse(f"{set_up_exams.app_name}:exam_overview", args=[e1]))
    assert response.status_code == 403

    response = client.get(reverse(f"{set_up_exams.app_name}:exam_overview", args=[e2]))
    assert response.status_code == 200


@pytest.mark.parametrize("exam_views", EXAM_VIEWS)
def test_index(client, create_superuser, exam_views, django_user_model):

    basic_user = django_user_model.objects.create_user(
        "basicuser", "user@user.net", "pass2"
    )

    e1 = exam_views.Exam.objects.create(name="test exam", exam_mode=True)
    e = exam_views.Exam.objects.create(name="test exam 2", exam_mode=True)
    e.author.add(basic_user)

    client.login(username="admin", password="adminpassword")
    response = client.get(reverse(f"{exam_views.app_name}:index"))
    assert response.status_code == 200

    assert (
        BeautifulSoup(response.content, "html.parser")
        .find("h4", {"class": "exam-number-title"})
        .getText()
        == "2 exams found."
    )

    
    response = client.get(reverse(f"{exam_views.app_name}:exam_list"))
    assert response.status_code == 200
    assert (
        len(BeautifulSoup(response.content, "html.parser")
        .select("a.exam-name"))
        == 2
    )

    if exam_views.app_name in JSON_APPS:
        response = client.get(reverse(f"{exam_views.app_name}:active_exams"))

        json_response = json.loads(response.content)["exams"]

        assert len(json_response) == 2

        for json_exam in json_response:
            eid_app_type, eid = json_exam["eid"].split("/")
            # hack for long / longs mismathc
            assert (
                eid_app_type == exam_views.app_name
                or eid_app_type == exam_views.app_name[:-1]
            )

            assert exam_views.Exam.objects.get(pk=int(eid)).name == json_exam["name"]

        add_user_response = client.post(
            reverse(f"{exam_views.app_name}:exam_json_edit", args=(e1.pk,)),
            {"edit_user_user": basic_user.pk, "add": "true"},
            HTTP_X_REQUESTED_WITH="XMLHttpRequest",
        )


        assert json.loads(add_user_response.content)["status"] == "success"

    client.logout()

    client.force_login(basic_user)

    response = client.get(reverse(f"{exam_views.app_name}:index"))
    assert response.status_code == 200
    assert (
        BeautifulSoup(response.content, "html.parser")
        .find("h4", {"class": "exam-number-title"})
        .getText()
        == "1 exams found."
    )

    response = client.get(reverse(f"{exam_views.app_name}:exam_list"))

    assert (
        len(BeautifulSoup(response.content, "html.parser")
        .select("a.exam-name"))
        == 1
    )


    if exam_views.app_name in JSON_APPS:
        response = client.get(reverse(f"{exam_views.app_name}:active_exams"))

        json_response = json.loads(response.content)["exams"]

        assert len(json_response) == 1

        e1.active = True
        e1.save()

        response = client.get(reverse(f"{exam_views.app_name}:active_exams"))

        json_response = json.loads(response.content)["exams"]

        assert len(json_response) == 2

def test_cid_management(client, create_cid_manager, django_user_model):
    urls = [
        reverse(f"people"),
        #reverse(f"generic:update_cid"),
        #reverse(f"generic:update_cid_exams"),
        reverse(f"generic:manage_cids"),
        reverse(f"generic:manage_cid_exams"),
        reverse(f"generic:cid_group_view"),
        reverse(f"generic:cid_group_view_all"),
        reverse(f"generic:cid_group_create"),
    ]

    for url in urls:
        response = client.get(url)
        assert response.status_code == 403

    pass

    cid_manager = create_cid_manager

    client.force_login(cid_manager)

    for url in urls:
        response = client.get(url)
        assert response.status_code == 200

    pass