import secrets
from typing import Any, Optional
import os
import re
from io import StringIO
from datetime import datetime
from django.conf import settings

from django_tables2 import SingleTableMixin
from atlas.models import CaseCollection, CidReportAnswer, Case as AtlasCase
from generic.decorators import user_is_cid_user_manager
from generic.filters import UserUserFilter
from generic.tables import UserUserTable
from generic.views import (
    CidManagerRequiredMixin,
    RedirectMixin,
    get_question_and_content_type,
    get_user_exams,
    get_exam_model_from_app_name,
)
from django.core.exceptions import PermissionDenied, ObjectDoesNotExist
from django.shortcuts import render, get_object_or_404, redirect
from django.views.decorators.csrf import csrf_exempt
from django import forms

from django.core.exceptions import ValidationError
from django.core.validators import validate_email

from django.utils.html import format_html
from django.utils.safestring import mark_safe

# from django.contrib.auth.models import User
from django.contrib.auth.decorators import login_required, user_passes_test
from django.contrib.auth.forms import PasswordResetForm
from django.contrib.auth.models import User

from django.contrib.contenttypes.models import ContentType

from django.contrib.auth.mixins import LoginRequiredMixin

from django.views.generic.edit import CreateView, UpdateView, DeleteView
from django.views.generic import ListView, TemplateView

from django.db.models.functions import Lower

from django.core.cache import cache

from django.urls import reverse_lazy, reverse

from django.http import Http404, JsonResponse

from django.http import HttpResponseRedirect, HttpResponse
from django.views.decorators.http import require_POST
from django.core.management import call_command, CommandError

from physics.models import UserAnswer as PhysicsUserAnswer
from physics.models import Exam as PhysicsExam

from anatomy.models import UserAnswer as AnatomyUserAnswer
from anatomy.models import Exam as AnatomyExam
from anatomy.models import AnatomyQuestion
from anatomy.models import Answer as AnatomyAnswer
from rad.filters import UserListFilter

from helpers.cimar import CimarAPI, InvalidCredentials, NoSession
from rapids.models import UserAnswer as RapidsUserAnswer
from rapids.models import Exam as RapidsExam
from rapids.models import Rapid
from rapids.models import Answer as RapidAnswer

from longs.models import UserAnswer as LongsUserAnswer
from longs.models import Exam as LongsExam
from longs.models import Long

from sbas.models import UserAnswer as SbasUserAnswer
from sbas.models import Exam as SbasExam

from anatomy.views import GenericExamViews as AnatomyExamViews
from rapids.views import GenericExamViews as RapidsExamsViews
from shorts.views import GenericExamViews as ShortsExamsViews
from longs.views import GenericExamViews as LongsExamsViews

from generic.forms import QuestionNoteForm
from generic.models import (
    CidUser,
    CimarCase,
    ExamCollection,
    QuestionNote,
    Supervisor,
    UserGrades,
    UserProfile,
    USER_EXAM_TYPES,
)
from django.contrib.auth.models import Group
from generic.models import UserUserGroup

from django_filters.views import FilterView

import json

from django.template import RequestContext

from django.db.models import Q

from dal import autocomplete

from loguru import logger
from .logging_setup import get_log_file_path

import psutil




def _media_file_inventory(path: str) -> dict[str, int]:
    """Return a mapping of file path to byte size for files under a directory."""
    if not path or not os.path.exists(path):
        return {}

    inventory: dict[str, int] = {}
    for root, _, files in os.walk(path):
        for filename in files:
            file_path = os.path.join(root, filename)
            try:
                inventory[file_path] = os.path.getsize(file_path)
            except OSError:
                continue

    return inventory


def feedback_checker(user):
    return user.groups.filter(name="feedback_checker").exists()


@user_passes_test(lambda u: u.is_superuser)
def server(request):
    return render(request, "server.html")


@user_is_cid_user_manager
def people(request):
    """Render the people management overview or search users via HTMX.

    Scope: managers and superusers.
    Functionality: provides details on user roles/groups, and a single search
    input that filters users dynamically via HTMX GET requests.
    """
    if request.htmx:
        q = request.GET.get("q", "").strip()
        if not q:
            return HttpResponse("")

        users = (
            User.objects.filter(
                Q(first_name__icontains=q)
                | Q(last_name__icontains=q)
                | Q(email__icontains=q)
                | Q(username__icontains=q)
            )
            .prefetch_related(
                "userprofile", "userprofile__grade", "userprofile__supervisor", "user_groups"
            )
            .order_by("first_name", "last_name", "username")[:20]
        )

        return render(
            request,
            "rad/partials/_people_search_results.html",
            {"users": users, "q": q},
        )

    return render(request, "people.html", {})



@login_required
def profile(request):
    """Render the current user's profile page with group management context.

    Scope: authenticated user's own profile view.
    Functionality: provides user details, available groups, and supervisor
    account state for template actions.
    """
    user = request.user
    available_groups = UserUserGroup.objects.filter(archive=False).exclude(
        pk__in=user.user_groups.values_list("pk", flat=True)
    )
    available_auth_groups = Group.objects.exclude(
        pk__in=user.groups.values_list("pk", flat=True)
    )
    is_cid_user_manager = request.user.groups.filter(name="cid_user_manager").exists()
    supervisor_account = Supervisor.objects.filter(user=user).first()
    return render(
        request,
        "profile.html",
        {
            "user": user,
            "available_groups": available_groups,
            "available_auth_groups": available_auth_groups,
            "is_cid_user_manager": is_cid_user_manager,
            "supervisor_account": supervisor_account,
            "supervisor_action": request.GET.get("supervisor_action", ""),
            "password_reset_action": request.GET.get("password_reset_action", ""),
        },
    )


def index(request):
    collections = []

    if request.user.is_authenticated:
        collections = ExamCollection.objects.filter(archive=False, author=request.user)

    rcr_assessor = request.user.groups.filter(
        Q(name="rcr_radiology_assessor")
        | Q(name="rcr_oncology_assessor")
        | Q(name="rcr_assessor")
    ).exists()
    return render(
        request,
        "index.html",
        {"rcr_assessor": rcr_assessor, "collections": collections},
    )


@user_is_cid_user_manager
def account_profile(request, slug):
    """Render an account profile page for administrators.

    Scope: cid_user_manager and superusers viewing another user's profile.
    Functionality: exposes profile details, group controls, and supervisor
    account creation/link status for admin actions.
    """
    user = get_object_or_404(User, username=slug)
    available_groups = UserUserGroup.objects.filter(archive=False).exclude(
        pk__in=user.user_groups.values_list("pk", flat=True)
    )
    available_auth_groups = Group.objects.exclude(
        pk__in=user.groups.values_list("pk", flat=True)
    )
    is_cid_user_manager = request.user.groups.filter(name="cid_user_manager").exists()
    supervisor_account = Supervisor.objects.filter(user=user).first()
    return render(
        request,
        "profile.html",
        {
            "user": user,
            "available_groups": available_groups,
            "available_auth_groups": available_auth_groups,
            "is_cid_user_manager": is_cid_user_manager,
            "supervisor_account": supervisor_account,
            "supervisor_action": request.GET.get("supervisor_action", ""),
            "password_reset_action": request.GET.get("password_reset_action", ""),
        },
    )


@require_POST
@user_is_cid_user_manager
def account_set_supervisor(request, slug):
    """Create or link a Supervisor record for an existing user.

    Scope: cid_user_manager and superusers only.
    Functionality: one-click action from profile pages to assign a user as a
    supervisor account, reusing an existing supervisor by email when safe.
    """
    user = get_object_or_404(User, username=slug)

    next_url = request.POST.get("next") or reverse("account_profile", kwargs={"slug": user.username})

    email = (user.email or "").strip().lower()
    if not email:
        return redirect(f"{next_url}?supervisor_action=no_email")

    existing_for_user = Supervisor.objects.filter(user=user).first()
    if existing_for_user:
        return redirect(f"{next_url}?supervisor_action=already_linked")

    supervisor = Supervisor.objects.filter(email__iexact=email).first()
    if supervisor:
        if supervisor.user and supervisor.user != user:
            return redirect(f"{next_url}?supervisor_action=email_in_use")

        supervisor.user = user
        if not supervisor.name:
            supervisor.name = user.get_full_name().strip() or user.username
        supervisor.save()
        return redirect(f"{next_url}?supervisor_action=linked")

    name = user.get_full_name().strip() or user.username
    Supervisor.objects.create(email=email, name=name, user=user)
    return redirect(f"{next_url}?supervisor_action=created")


@require_POST
@user_is_cid_user_manager
def account_send_password_reset(request, slug):
    """Send a password reset email for an existing user from their profile page."""
    user = get_object_or_404(User, username=slug)

    next_url = request.POST.get("next") or reverse("account_profile", kwargs={"slug": user.username})
    email = (user.email or user.username or "").strip()

    if not email:
        return redirect(f"{next_url}?password_reset_action=no_email")

    if not user.is_active:
        return redirect(f"{next_url}?password_reset_action=inactive")

    form = PasswordResetForm({"email": email})
    if not form.is_valid():
        return redirect(f"{next_url}?password_reset_action=invalid")

    try:
        form.save(
            request=request,
            use_https=request.is_secure(),
            from_email=getattr(settings, "DEFAULT_FROM_EMAIL", None),
        )
    except Exception:
        logger.exception("Failed to send password reset email for user {}", user.pk)
        return redirect(f"{next_url}?password_reset_action=error")

    return redirect(f"{next_url}?password_reset_action=sent")


@user_passes_test(lambda u: u.is_superuser)
def logs_view(request):
    """Display production logs with search/filter controls.
    
    Scope: superusers only.
    Functionality: reads the configured application log file and displays entries with optional text search filter.
    Supports ?all=1 to show all entries without pagination limit.
    """
    log_file_path = str(get_log_file_path())
    search_query = request.GET.get("q", "").strip()
    level_filter = request.GET.get("level", "").strip().upper()
    show_all = request.GET.get("all") == "1"
    raw_mode = request.GET.get("raw") == "1"
    include_noise = request.GET.get("include_noise") == "1"
    date_from_raw = request.GET.get("date_from", "").strip()
    date_to_raw = request.GET.get("date_to", "").strip()
    time_from_raw = request.GET.get("time_from", "").strip()
    time_to_raw = request.GET.get("time_to", "").strip()
    action_message = ""

    if request.method == "POST" and request.POST.get("action") == "clear":
        try:
            os.makedirs(os.path.dirname(log_file_path), exist_ok=True)
            with open(log_file_path, "w", encoding="utf-8"):
                pass
            action_message = "Log file cleared."
        except Exception as exc:
            action_message = f"Failed to clear log file: {exc}"

    def _parse_log_timestamp(timestamp_text: str) -> datetime | None:
        if not timestamp_text:
            return None
        for timestamp_format in ("%d/%b/%Y %H:%M:%S", "%Y-%m-%d %H:%M:%S"):
            try:
                return datetime.strptime(timestamp_text, timestamp_format)
            except ValueError:
                continue
        return None

    def _parse_date_input(value: str):
        if not value:
            return None
        try:
            return datetime.strptime(value, "%Y-%m-%d").date()
        except ValueError:
            return None

    def _parse_time_input(value: str):
        if not value:
            return None
        for time_format in ("%H:%M", "%H:%M:%S"):
            try:
                return datetime.strptime(value, time_format).time()
            except ValueError:
                continue
        return None

    date_from = _parse_date_input(date_from_raw)
    date_to = _parse_date_input(date_to_raw)
    time_from = _parse_time_input(time_from_raw)
    time_to = _parse_time_input(time_to_raw)

    if raw_mode:
        if not os.path.exists(log_file_path):
            return HttpResponse(
                f"Log file not found at {log_file_path}\n",
                content_type="text/plain; charset=utf-8",
                status=404,
            )

        try:
            with open(log_file_path, "r", encoding="utf-8", errors="ignore") as f:
                raw_content = f.read()
        except Exception as e:
            return HttpResponse(
                f"Error reading log file: {str(e)}\n",
                content_type="text/plain; charset=utf-8",
                status=500,
            )

        return HttpResponse(raw_content, content_type="text/plain; charset=utf-8")

    log_header_re = re.compile(
        r"^\[(?P<timestamp>[^\]]+)\]\s+(?P<level>[A-Z]+)\s+\[(?P<logger>[^:\]]+):(?P<line>\d+)\]\s+(?P<message>.*)$"
    )

    parsed_entries: list[dict[str, Any]] = []
    if os.path.exists(log_file_path):
        try:
            with open(log_file_path, "r", encoding="utf-8", errors="ignore") as f:
                lines = f.readlines()

            current_entry = None
            for raw_line in lines:
                line = raw_line.rstrip("\n")
                if not line.strip():
                    if current_entry is not None:
                        current_entry["details"].append("")
                    continue

                header_match = log_header_re.match(line)
                if header_match:
                    if current_entry is not None:
                        parsed_entries.append(current_entry)

                    current_entry = {
                        "timestamp": header_match.group("timestamp"),
                        "level": header_match.group("level"),
                        "logger": header_match.group("logger"),
                        "source_line": header_match.group("line"),
                        "message": header_match.group("message"),
                        "details": [],
                    }
                    continue

                if current_entry is not None:
                    current_entry["details"].append(line)
                else:
                    parsed_entries.append(
                        {
                            "timestamp": "",
                            "level": "RAW",
                            "logger": "",
                            "source_line": "",
                            "message": line,
                            "details": [],
                        }
                    )

            if current_entry is not None:
                parsed_entries.append(current_entry)

        except Exception as e:
            parsed_entries = [
                {
                    "timestamp": "",
                    "level": "ERROR",
                    "logger": "logs_view",
                    "source_line": "",
                    "message": f"Error reading log file: {str(e)}",
                    "details": [],
                }
            ]
    else:
        parsed_entries = [
            {
                "timestamp": "",
                "level": "ERROR",
                "logger": "logs_view",
                "source_line": "",
                "message": f"Log file not found at {log_file_path}",
                "details": [],
            }
        ]

    # Most recent first.
    parsed_entries = list(reversed(parsed_entries))

    available_levels = sorted({entry["level"] for entry in parsed_entries if entry["level"]})

    filtered_entries = []
    search_lower = search_query.lower()
    noise_suppressed = 0
    for entry in parsed_entries:
        # Django template debug logs can be very noisy and usually do not indicate
        # fatal issues. Hide them by default, with an explicit opt-in toggle.
        is_template_debug_noise = (
            entry.get("level") == "DEBUG"
            and entry.get("logger") == "django.template"
            and (
                "Exception while resolving variable" in entry.get("message", "")
                or any("VariableDoesNotExist" in d for d in entry.get("details", []))
            )
        )
        if is_template_debug_noise and not include_noise:
            noise_suppressed += 1
            continue

        if level_filter and entry["level"] != level_filter:
            continue

        haystack = "\n".join(
            [
                entry.get("timestamp", ""),
                entry.get("level", ""),
                entry.get("logger", ""),
                entry.get("message", ""),
                "\n".join(entry.get("details", [])),
            ]
        ).lower()
        if search_lower and search_lower not in haystack:
            continue

        entry_timestamp = _parse_log_timestamp(entry.get("timestamp", ""))
        if date_from or date_to or time_from or time_to:
            if entry_timestamp is None:
                continue
            if date_from and entry_timestamp.date() < date_from:
                continue
            if date_to and entry_timestamp.date() > date_to:
                continue
            if time_from and entry_timestamp.time() < time_from:
                continue
            if time_to and entry_timestamp.time() > time_to:
                continue

        filtered_entries.append(entry)

    total = len(filtered_entries)
    limit = None if show_all else 500
    displayed_entries = filtered_entries[:limit] if limit else filtered_entries

    return render(
        request,
        "logs_viewer.html",
        {
            "entries": displayed_entries,
            "total_entries": total,
            "search_query": search_query,
            "level_filter": level_filter,
            "available_levels": available_levels,
            "log_file_path": log_file_path,
            "show_all": show_all,
            "limit": limit,
            "raw_url": f"{reverse('logs_view')}?raw=1",
            "include_noise": include_noise,
            "noise_suppressed": noise_suppressed,
            "date_from": date_from_raw,
            "date_to": date_to_raw,
            "time_from": time_from_raw,
            "time_to": time_to_raw,
            "action_message": action_message,
        },
    )


@login_required
@user_is_cid_user_manager
def media_cleanup(request):
    """Run django-unused-media cleanup from a manager-facing maintenance page.

    Scope: cid_user_manager group members and superusers.
    Functionality: supports safe preview (dry-run) and confirmed deletion runs,
    returning HTMX fragments for inline results.
    """
    context: dict[str, Any] = {
        "ran": False,
        "action": "preview",
        "minimum_file_age": 60,
        "remove_empty_dirs": True,
        "exclude": "",
    }

    if request.method == "POST":
        action = request.POST.get("action", "preview")
        dry_run = action != "cleanup"
        exclude_raw = (request.POST.get("exclude") or "").strip()
        exclude = [line.strip() for line in exclude_raw.splitlines() if line.strip()]
        remove_empty_dirs = request.POST.get("remove_empty_dirs") == "on"

        min_age_raw = (request.POST.get("minimum_file_age") or "60").strip()
        try:
            minimum_file_age = max(0, int(min_age_raw))
        except (TypeError, ValueError):
            minimum_file_age = 0

        out = StringIO()
        success = True

        command_kwargs: dict[str, Any] = {
            "dry_run": dry_run,
            "no_input": True,
            "interactive": False,
            "minimum_file_age": minimum_file_age,
            "remove_empty_dirs": remove_empty_dirs,
            "verbosity": 2,
            "stdout": out,
        }
        if exclude:
            command_kwargs["exclude"] = exclude

        error_message = ""
        media_inventory_before = _media_file_inventory(settings.MEDIA_ROOT)
        media_inventory_after = media_inventory_before
        try:
            call_command("cleanup_unused_media", **command_kwargs)
        except CommandError as exc:
            success = False
            error_message = str(exc)
        except Exception as exc:  # pragma: no cover
            success = False
            error_message = str(exc)

        media_inventory_after = _media_file_inventory(settings.MEDIA_ROOT)

        media_size_before = sum(media_inventory_before.values())
        media_size_after = sum(media_inventory_after.values())
        removed_files = set(media_inventory_before) - set(media_inventory_after)

        output = out.getvalue().strip()
        # Use before/after total delta so reported recovered space matches real disk impact.
        recovered_size = max(0, media_size_before - media_size_after)
        context.update(
            {
                "ran": True,
                "success": success,
                "action": action,
                "dry_run": dry_run,
                "minimum_file_age": minimum_file_age,
                "remove_empty_dirs": remove_empty_dirs,
                "exclude": exclude_raw,
                "output": output,
                "error_message": error_message,
                "media_size_before": media_size_before,
                "media_size_after": media_size_after,
                "recovered_size": recovered_size,
                "removed_file_count": len(removed_files),
            }
        )

        if request.htmx:
            return render(request, "rad/partials/_media_cleanup_result.html", context)

    return render(request, "rad/media_cleanup.html", context)


def cid_selector(request):
    return render(
        request,
        "cid_selector.html",
    )


@login_required
@user_passes_test(lambda u: u.is_superuser)
def cid_scores_admin(request, cid):
    cid_user = CidUser.objects.filter(cid=cid).first()

    if not cid_user:
        raise Http404("CID not found")

    return cid_user_overview(request, cid_user.cid, cid_user.passcode)


@login_required
# @user_passes_test(lambda u: u.is_superuser)
@user_is_cid_user_manager
def cid_results(request, cid):
    cid_user = CidUser.objects.filter(cid=cid).first()

    if not cid_user:
        raise Http404("CID not found")

    report = cid_user.generate_exam_report()

    return render(
        request,
        "cid_results.html",
        {
            "report": report,
        },
    )


@user_passes_test(lambda u: u.is_superuser)
def user_scores_admin(request, user_id):
    try:
        user = User.objects.get(id=user_id)
    except User.DoesNotExist:
        raise Http404("Cid not found")

    return user_scores(request, user=user)


@login_required
def user_scores(request, user=None):
    admin = True
    if user is None:
        user = request.user
        admin = False

    from django.contrib.contenttypes.models import ContentType
    from generic.models import UserHiddenItem

    show_hidden = request.GET.get("show_hidden") in ("true", "1")

    # Fetch user's hidden items map: {content_type_id: {object_ids}}
    hidden_map = {}
    for ct_id, obj_id in UserHiddenItem.objects.filter(user=user).values_list("content_type_id", "object_id"):
        hidden_map.setdefault(ct_id, set()).add(obj_id)

    # Filter Exam Results list (all_exams)
    exams = get_user_exams(user)
    filtered_exams = []
    for exam_type, exams_qs in exams:
        exam_model = exams_qs.model
        ct_id = ContentType.objects.get_for_model(exam_model).id
        hidden_ids = hidden_map.get(ct_id, set())

        if not show_hidden:
            exams_qs = exams_qs.exclude(id__in=hidden_ids)

        exams_list = list(exams_qs)
        for exam in exams_list:
            exam.is_hidden = exam.id in hidden_ids

        if exams_list:
            filtered_exams.append((exam_type, exams_list))

    # Filter Assigned Exams list (available_exams)
    available_exams = []
    for n, t in USER_EXAM_TYPES:
        exam_rel = getattr(user, t)
        if exam_rel.exists():
            temp_exams = exam_rel.filter(exam_mode=True, archive=False).order_by("name")
            exam_model = temp_exams.model
            ct_id = ContentType.objects.get_for_model(exam_model).id
            hidden_ids = hidden_map.get(ct_id, set())

            if not show_hidden:
                temp_exams = temp_exams.exclude(id__in=hidden_ids)

            temp_exams_list = list(temp_exams)
            for exam in temp_exams_list:
                exam.is_hidden = exam.id in hidden_ids

            if temp_exams_list:
                available_exams.append((n, temp_exams_list))

    return render(
        request,
        "user_scores.html",
        {
            "all_exams": filtered_exams,
            "cid_user": user,
            "available_exams": available_exams,
            "case_collections": [],
            "admin": admin,
            "show_hidden": show_hidden,
        },
    )



@login_required
def user_marking(request):
    """Main page for user marking overview. Uses HTMX to fetch per-app partials."""
    apps = ["physics", "anatomy", "rapids", "shorts", "longs", "sbas"]
    return render(request, "rad/user_marking.html", {"apps": apps})


@login_required
def user_marking_partial(request, exam_type: str):
    """Return an HTMX partial listing exams the user can mark for a given exam type.

    Each exam is checked for whether it has any unmarked answers (using
    question.get_unmarked_user_answer_count when available).
    """
    user = request.user

    try:
        ExamModel = get_exam_model_from_app_name(exam_type)
    except Exception:
        return HttpResponse("Unknown exam type", status=400)

    # Exams where user is an author or an authorised marker
    exams_qs = (
        ExamModel.objects.filter(archive=False, exam_mode=True)
        .filter(Q(author=user) | Q(markers=user))
        .distinct()
        .order_by("name")
        .prefetch_related("author", "markers")
    )

    exams_data = []
    for exam in exams_qs:
        has_unmarked = False
        unmarked_count = 0
        # iterate questions and use their helper to count unmarked answers when available
        for q in exam.get_questions():
            count = 0
            # Prefer question-provided helper if present
            helper = getattr(q, "get_unmarked_user_answer_count", None)
            if callable(helper):
                try:
                    count = helper(exam_pk=exam.pk, marker=user)
                except TypeError:
                    count = helper(exam_pk=exam.pk)
                except Exception:
                    count = 0
            else:
                # Fallback: inspect related answer manager if present
                rel_manager = None
                for rel_name in ("cid_user_answers", "user_answers", "answers", "useranswer_set"):
                    if hasattr(q, rel_name):
                        rel_manager = getattr(q, rel_name)
                        break

                if rel_manager is not None:
                    try:
                        ans_model = rel_manager.model
                        # If the answer model has a `score` field, count answers that are unmarked
                        field_names = [f.name for f in ans_model._meta.get_fields()]
                        if "score" in field_names:
                            # Try to detect an UNMARKED constant on the model
                            unmarked_vals = [None, ""]
                            model_score_const = getattr(ans_model, "ScoreOptions", None) or getattr(ans_model, "MarkOptions", None)
                            if model_score_const is not None:
                                # attempt to use any UNMARKED attribute
                                unmarked_val = getattr(model_score_const, "UNMARKED", None)
                                if unmarked_val is not None:
                                    unmarked_vals.append(unmarked_val)

                            count = rel_manager.filter(exam__id=exam.pk).filter(score__in=unmarked_vals).count()
                        else:
                            # No score field — likely auto-marked; treat as 0
                            count = 0
                    except Exception:
                        count = 0

            try:
                c = int(count)
            except Exception:
                c = 0
            if c:
                has_unmarked = True
                unmarked_count += c

        exams_data.append({"exam": exam, "has_unmarked": has_unmarked, "unmarked_count": unmarked_count})

    return render(request, "generic/partials/user_marking_exam_list.html", {"exams_data": exams_data, "exam_type": exam_type})


def cid_user_overview(request, cid, passcode):
    # exam = get_object_or_404(Exam, pk=pk)

    cid_user = CidUser.objects.filter(cid=cid).first()
    if not cid_user or cid_user.passcode != passcode:
        raise Http404("CID / Passcode combination not found")

    EXAM_ANSWER_MAP = {
        "physics": (PhysicsUserAnswer, PhysicsExam),
        "anatomy": (AnatomyUserAnswer, AnatomyExam),
        "rapids": (RapidsUserAnswer, RapidsExam),
        "longs": (LongsUserAnswer, LongsExam),
        "sbas": (SbasUserAnswer, SbasExam),
    }
    kwargs = {"exam_mode": True, "archive": False}

    exams = []
    for exam_type in EXAM_ANSWER_MAP:
        UserAnswer, Exam = EXAM_ANSWER_MAP[exam_type]
        exam_answers = UserAnswer.objects.filter(cid=cid)
        exam_ids = exam_answers.values_list("exam").distinct()
        logger.debug(f"DEBUG cid_user_overview: {exam_type=}, {cid=}, answers_count={exam_answers.count()}, exam_ids={list(exam_ids)}")
        exams_to_add = Exam.objects.filter(id__in=exam_ids, **kwargs)
        logger.debug(f"DEBUG cid_user_overview: {exams_to_add=}")
        if exams_to_add:
            exams.append((exam_type, exams_to_add))

    case_collections = cid_user.casecollection_exams.all()

    available_exams = cid_user.get_cid_exams(include_case_collections=False)

    return render(
        request,
        "cid_user_overview.html",
        {
            # "physics_exams": physics_exams,
            # "anatomy_exams": anatomy_exams,
            # "rapid_exams": rapid_exams,
            # "longs_exams": longs_exams,
            # "sba_exams": sba_exams,
            "all_exams": exams,
            "cid": cid,
            "passcode": passcode,
            "cid_user": cid_user,
            "available_exams": available_exams,
            "case_collections": case_collections,
        },
    )


def active_exams(request, cid=None, passcode=None, based=True):
    active_exams = {}

    if cid is not None:
        active_exams["cid"] = cid
        cid_user = CidUser.objects.filter(cid=cid).first()
        if not cid_user or cid_user.passcode != passcode:
            return JsonResponse({"status": "invalid"}, status=401)

    anatomy_exams = AnatomyExamViews.active_exams(
        request, False, cid=cid, passcode=passcode
    )
    rapid_exams = RapidsExamsViews.active_exams(
        request, False, cid=cid, passcode=passcode
    )
    short_exams = ShortsExamsViews.active_exams(
        request, False, cid=cid, passcode=passcode
    )
    long_exams = LongsExamsViews.active_exams(request, False, cid=cid, passcode=passcode)

    exams = []
    exams.extend(anatomy_exams)
    exams.extend(rapid_exams)
    exams.extend(short_exams)
    exams.extend(long_exams)

    active_exams["exams"] = exams

    if request.user:
        active_exams["user"] = request.user.username
        active_exams["user_id"] = request.user.pk
    else:
        active_exams["user"] = False

    return JsonResponse(active_exams)


def active_exams_unbased(request, cid=None, passcode=None):
    return active_exams(request, cid, passcode, based=False)


def active_exams_by_type(request, exam_type, cid=None, passcode=None, based=True):
    active_exams_data = {}

    if cid is not None:
        active_exams_data["cid"] = cid
        cid_user = CidUser.objects.filter(cid=cid).first()
        if not cid_user or cid_user.passcode != passcode:
            return JsonResponse({"status": "invalid"}, status=401)

    exams = []
    if exam_type == "anatomy":
        exams = AnatomyExamViews.active_exams(
            request, False, cid=cid, passcode=passcode
        )
    elif exam_type == "rapid":
        exams = RapidsExamsViews.active_exams(
            request, False, cid=cid, passcode=passcode
        )
    elif exam_type == "short":
        exams = ShortsExamsViews.active_exams(
            request, False, cid=cid, passcode=passcode
        )
    elif exam_type == "long":
        exams = LongsExamsViews.active_exams(
            request, False, cid=cid, passcode=passcode
        )

    active_exams_data["exams"] = exams

    if request.user and request.user.is_authenticated:
        active_exams_data["user"] = request.user.username
        active_exams_data["user_id"] = request.user.pk
    else:
        active_exams_data["user"] = False

    return JsonResponse(active_exams_data)


def active_exams_by_type_unbased(request, exam_type, cid=None, passcode=None):
    return active_exams_by_type(request, exam_type, cid, passcode, based=False)


@csrf_exempt
def exam_submit(request):
    if request.method == "POST":
        exam_type, exam_id = request.POST.get("eid").split("/")

        try:
            if exam_type == "anatomy":
                return AnatomyExamViews.post_exam_answers(request)
            elif exam_type == "rapid":
                return RapidsExamsViews.post_exam_answers(request)
            elif exam_type == "long":
                return LongsExamsViews.post_exam_answers(request)
            elif exam_type == "short":
                return ShortsExamsViews.post_exam_answers(request)

            return JsonResponse({"success": False, "error": "Invalid exam type"})
        except ObjectDoesNotExist:
            return JsonResponse({"success": False, "error": "Invalid data"})

    # post_exam_answers
    return JsonResponse({"success": False, "error": "Invalid data"})


def feedback_create(request, question_type, pk):
    if question_type == "anatomy":
        question = AnatomyQuestion
    elif question_type == "rapid":
        question = Rapid
    elif question_type == "long":
        question = Long

    return JsonResponse({"success": False, "error": "Invalid exam type"})


class AddQuestionNote(CreateView):
    model = QuestionNote
    form_class = QuestionNoteForm

    # fields = ("author", "note_type", "note")

    def get_form_kwargs(self):
        kwargs = super(AddQuestionNote, self).get_form_kwargs()
        # update the kwargs for the form init method with yours
        kwargs.update(self.kwargs)  # self.kwargs contains all url conf params
        kwargs.update({"user": self.request.user})
        return kwargs

    def get_initial(self):
        pk = self.kwargs["pk"]
        self.question_type = self.kwargs["question_type"]

        question, content_type = get_question_and_content_type(self.question_type)

        self.question = get_object_or_404(question, pk=pk)
        return {"content_type": content_type, "object_id": pk}

    def get_context_data(self, **kwargs):
        # This can also be accessed via view.**** in the template
        context = super(AddQuestionNote, self).get_context_data(**kwargs)
        context["question"] = self.question
        context["question_type"] = self.question_type
        return context

    def form_valid(self, form):
        model = form.save(commit=False)

        if self.request.user.is_authenticated:
            model.user_author = self.request.user

        model.save()

        response = super().form_valid(form)

        return render(self.request, "feedback_submitted.html")
        return response

    def get_success_url(self) -> str:
        return super().get_success_url()


@user_passes_test(lambda u: u.is_superuser)
def feedback_note_delete(request, pk):
    q = get_object_or_404(QuestionNote, pk=pk)
    q.delete()

    return redirect(q.get_object_url())


@login_required
def feedback_mark_complete(request, pk):
    q = get_object_or_404(QuestionNote, pk=pk)

    if (
        request.user not in q.question.author.all()
        and not request.user.groups.filter(name="feedback_checker").exists()
    ):
        raise PermissionDenied()

    q.complete = True
    q.save()
    return redirect(q.get_object_url())


@login_required
def answer_suggestion_submit(request):
    """Submit a proposed answer to a question for review.

    Scope: authenticated users only.
    Functionality: accepts a JSON POST containing the question ID, proposed answer
    string, and status; creates a new Answer record marked as proposed=True for
    moderator review. Only 'anatomy' and 'rapid' question types are supported.
    """
    if request.method != "POST":
        return JsonResponse({"success": False, "error": "Invalid data"})

    post_data = json.loads(request.body)
    question_type, qid = post_data["qid"].split("/")
    answer_string = post_data["answer"]
    status = post_data["status"]

    if str(status) not in " 012":
        return JsonResponse({"success": False, "error": "Invalid status"})

    if question_type == "anatomy":
        AnswerModel = AnatomyAnswer
        question = AnatomyQuestion
    elif question_type == "rapid":
        AnswerModel = RapidAnswer
        question = Rapid
    else:
        return JsonResponse({"success": False, "error": "Invalid question type"})

    q = get_object_or_404(question, pk=qid)
    if AnswerModel.objects.filter(answer=answer_string, question=q):
        return JsonResponse({"success": False, "error": "Answer already exists"})

    a = AnswerModel(question=q, answer=answer_string, status=status, proposed=True)
    a.save()
    return JsonResponse({"success": True, "error": "Answer submitted"})


@login_required
def answer_submit(request):
    if request.method == "POST":
        qid = request.POST.get("qid")
        question_type = request.POST.get("question_type")
        answer_string = request.POST.get("answer")
        status = request.POST.get("status")

        if str(status) not in "012":
            return JsonResponse({"success": False, "error": "Invalid status"})

        if question_type == "anatomy":
            AnswerModel = AnatomyAnswer
            question = AnatomyQuestion
        elif question_type == "rapid":
            AnswerModel = RapidAnswer
            question = Rapid
        else:
            return JsonResponse({"success": False, "error": "Invalid question type"})

        q = get_object_or_404(question, pk=qid)
        if AnswerModel.objects.filter(answer=answer_string, question=q):
            return JsonResponse({"success": False, "error": "Answer already exists"})

        a = AnswerModel(question=q, answer=answer_string, status=status)
        a.save()
        return JsonResponse({"success": True, "error": "Answer added"})

    return JsonResponse({"success": False, "error": "Invalid data"})


@login_required
def answer_suggestion_confirm(request):
    if request.method == "POST":
        question_type = request.POST.get("question_type")
        aid = request.POST.get("aid")
        status = request.POST.get("status")

        if question_type == "anatomy":
            AnswerModel = AnatomyAnswer
            question = AnatomyQuestion
        elif question_type == "rapid":
            AnswerModel = RapidAnswer
            question = Rapid
        else:
            return JsonResponse({"success": False, "error": "Invalid question type"})

        answer = get_object_or_404(AnswerModel, pk=aid)
        answer.proposed = False
        answer.status = status
        answer.save()
        return JsonResponse({"success": True, "error": "Answer changed"})


@login_required
@user_passes_test(feedback_checker)
def view_feedback(request):
    # exam = get_object_or_404(Exam, pk=pk)

    feedback_notes = QuestionNote.objects.filter(complete=False)

    return render(
        request,
        "view_feedback.html",
        {
            "notes": feedback_notes,
        },
    )


def privacy_view(request):
    return render(request, "privacy.html")


def cimar(request):
    if "link_id" in request.GET:
        link_id = request.GET["link_id"]
        return render(request, "cimar.html", {"link_id": link_id})
    return render(request, "cimar.html")


def about_view(request):
    return render(request, "about.html")


def stats(request):
    collection_count = CaseCollection.objects.filter(archive=False).count()
    case_count = AtlasCase.objects.filter().count()

    anatomy_exam_count = AnatomyExam.objects.filter(archive=False).count()
    anatomy_question_count = AnatomyQuestion.objects.filter().count()
    return render(
        request,
        "stats.html",
        {
            "collection_count": collection_count,
            "case_count": case_count,
            "anatomy_exam_count": anatomy_exam_count,
            "anatomy_question_count": anatomy_question_count,
        },
    )


# HTTP Error 400
def page_not_found(request, exception):
    # Provide the exception message (reason) to the template so callers
    # can show a user-friendly explanation when available.
    context = {"reason": str(exception) if exception is not None else "Not found"}
    response = render(request, "404.html", context=context)

    response.status_code = 404

    return response


def page_forbidden(request, exception):
    response = render(request, "403.html", context={"exception": exception})

    response.status_code = 403

    return response


def server_error(request):
    response = render(request, "500.html")

    response.status_code = 500

    return response


class UserListView(CidManagerRequiredMixin, FilterView):
    model = User
    template_name = "user_list_view.html"

    filterset_class = UserListFilter


class UserListTableView(CidManagerRequiredMixin, SingleTableMixin, FilterView):
    model = User
    table_class = UserUserTable
    template_name = "generic/user_view.html"

    filterset_class = UserUserFilter

    # table_pagination = {"per_page": 5}

    def get_paginate_by(self, table_data) -> int | None:
        return 100
        # return super().get_paginate_by(table_data)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        # user = self.request.user

        # filters = {"archive": False, "exam_mode": True}

        # physics_exams = [(i.name, i.pk) for i in PhysicsExam.objects.filter(**filters)]
        # rapid_exams = [(i.name, i.pk) for i in RapidsExam.objects.filter(**filters)]
        # sba_exams = [(i.name, i.pk) for i in SbasExam.objects.filter(**filters)]
        # longs_exams = [(i.name, i.pk) for i in LongsExam.objects.filter(**filters)]
        # anatomy_exams = [(i.name, i.pk) for i in AnatomyExam.objects.filter(**filters)]
        # casecollection_exams = [
        #    (i.name, i.pk)
        #    for i in CaseCollection.objects.filter(archive=False, collection_type__gt=0)
        # ]

        # context["physics_exams"] = physics_exams
        # context["rapid_exams"] = rapid_exams
        # context["sba_exams"] = sba_exams
        # context["longs_exams"] = longs_exams
        # context["anatomy_exams"] = anatomy_exams
        # context["casecollection_exams"] = casecollection_exams

        # cid_user_groups = [
        #    (i.name, i.pk) for i in CidUserGroup.objects.filter(archive=False)
        # ]

        # context["cid_user_groups"] = cid_user_groups
        return context


class DeleteUserView(CidManagerRequiredMixin, DeleteView):
    model = User
    template_name: str = "confirm_delete.html"
    success_url = reverse_lazy("accounts_list")


class UpdateUserView(CidManagerRequiredMixin, UpdateView):
    model = User
    fields = [
        "first_name",
        "last_name",
        "email",
        "is_active",
    ]  # Keep listing whatever fields
    # the combined UserProfile and User exposes.
    template_name = "user_update.html"
    slug_field = "username"
    slug_url_kwarg = "slug"

    def get_success_url(self):
        view_name = "account_profile"
        # No need for reverse_lazy here, because it's called inside the method
        return reverse(view_name, kwargs={"slug": self.object.username})


class UpdateUserProfileAdminView(CidManagerRequiredMixin, UpdateView):
    model = UserProfile
    fields = [
        "supervisor",
        "grade",
        "registration_number",
        "peninsula_trainee",
    ]  # Keep listing whatever fields
    template_name = "user_update_profile.html"
    slug_field = "user__username"
    slug_url_kwarg = "slug"

    def get_success_url(self):
        view_name = "account_profile"
        # No need for reverse_lazy here, because it's called inside the method
        return reverse(view_name, kwargs={"slug": self.object.username})


class UpdateUserProfileView(UpdateView):
    model = UserProfile
    fields = [
        "supervisor",
        "grade",
        "registration_number",
        # "peninsula_trainee",
    ]  # Keep listing whatever fields
    template_name = "user_update_profile.html"
    slug_field = "user__username"
    slug_url_kwarg = "slug"

    def dispatch(self, request, *args, **kwargs):
        if (
            request.user.is_superuser
            or request.user.groups.filter(name="cid_user_manager").exists()
        ):
            self.fields = [
                "supervisor",
                "grade",
                "registration_number",
                "site",
                "peninsula_trainee",
            ]
        # Check permissions for the request.user here
        elif request.user != self.get_object().user:
            raise Http404
        elif request.user.userprofile.peninsula_trainee:
            self.fields = ["supervisor", "grade", "registration_number", "site"]

        else:
            self.fields = ["grade", "registration_number", "site"]
        return super().dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs: reverse_lazy) -> dict[str, Any]:
        context = super().get_context_data(**kwargs)

        form = context["form"]

        if "supervisor" in form.fields:
            # form.fields["supervisor"].queryset = Supervisor.objects.all()
            form.fields["supervisor"] = forms.ModelChoiceField(
                Supervisor.objects.all().order_by("name"),
                required=False,
                widget=autocomplete.ModelSelect2(url="generic:supervisor-autocomplete"),
            )
        return context

    def get_success_url(self):
        if "redirect" in self.request.GET:
            return self.request.GET["redirect"]

        if (
            self.request.user.is_superuser
            or self.request.user.groups.filter(name="cid_user_manager").exists()
        ):
            view_name = "account_profile"
            # No need for reverse_lazy here, because it's called inside the method
            return reverse(view_name, kwargs={"slug": self.object.username})
        else:
            return reverse("profile")


# class UpdateUser(TemplateView):
#
#    user_form_class = UserForm
#    comment_form_class = UserProfileForm
#    template_name = 'user_update.html'
#    slug_field = 'username'
#    slug_url_kwarg = 'slug'
#
#    def post(self, request):
#        post_data = request.POST or None
#        user_form = self.user_form_class(post_data, prefix='user')
#        profile_form = self.profile_form_class(post_data, prefix='userprofile')
#
#        context = self.get_context_data(post_form=user_form,
#                                        profile_form=profile_form)
#
#        if user_form.is_valid():
#            self.form_save(user_form)
#        if profile_form.is_valid():
#            self.form_save(profile_form)
#
#        return self.render_to_response(context)
#
#    def form_save(self, form):
#        obj = form.save()
#        #messages.success(self.request, "{} saved successfully".format(obj))
#        return obj
#
#    def get(self, request, *args, **kwargs):
#        return self.post(request, *args, **kwargs)


@user_is_cid_user_manager
def accounts_check_users(request):
    if request.method == "POST":
        users = json.loads(request.POST.get("user_list"))

        existing_users = []

        for email in users:
            if User.objects.filter(username=email).exists():
                existing_users.append(email)

        return JsonResponse({"users": existing_users})

    return


@user_is_cid_user_manager
def accounts_bulk_create_check(request):
    if not request.method == "POST":
        return HttpResponse("Invalid request")

    user = {}

    user["email"] = request.POST.get("email")
    user["first_name"] = request.POST.get("first_name")
    user["last_name"] = request.POST.get("last_name")
    user["grade"] = request.POST.get("grade")
    user["supervisor_email"] = request.POST.get("supervisor_email")
    user["supervisor_name"] = request.POST.get("supervisor_name")

    errors = []
    info = []

    if user["email"] == "undefined":
        errors.append("No email provided")

    if User.objects.filter(username=user["email"]).exists():
        errors.append("User already exists")

    if not UserGrades.objects.filter(name=user["grade"]):
        errors.append("Invalid grade")

    # Treat empty, missing or the string 'undefined' as no supervisor email provided
    if not user.get("supervisor_email") or user["supervisor_email"] == "undefined":
        # Supervisor email not provided; try to match by name
        if not user.get("supervisor_name"):
            errors.append("No supervisor provided")
        else:
            supervisor = Supervisor.objects.filter(name__iexact=user["supervisor_name"])
            if not supervisor.exists():
                info.append("Supervisor does not exist (will be created)")
            else:
                info.append("Supervisor exists (matched by name)")
                if supervisor.count() > 1:
                    errors.append("More than one supervisor with that name")
                # no further name check needed since matched by name
    else:
        supervisor = Supervisor.objects.filter(email=user["supervisor_email"])

        if not supervisor:
            info.append("Supervisor does not exist (will be created)")
        else:
            info.append("Supervisor exists")

            if supervisor.count() > 1:
                errors.append("More than one supervisor with that email")

            # Compare names case-insensitively and trimmed to avoid false mismatches
            try:
                sup_name = (supervisor.first().name or '').strip().lower()
                posted_name = (user.get("supervisor_name") or '').strip().lower()
                if posted_name and sup_name != posted_name:
                    errors.append("Supervisor name does not match")
            except Exception:
                pass

    if errors:
        return HttpResponse(
            format_html("<span class='error'>{}</span>", "<br/>".join(errors))
        )

    return HttpResponse(format_html("<span class='info'>{}</span>", "<br/>".join(info)))


@user_is_cid_user_manager
def accounts_bulk_create(request):
    if request.method == "POST":
        context = {}

        users = json.loads(request.POST.get("usersjson"))

        created_users = []
        existing_users = []
        error_text = ""

        try:
            users = json.loads(request.POST.get("usersjson"))

            for user in users:
                try:
                    existing_user = User.objects.get(username=user["email"])
                    existing_users.append(user["email"])

                    user_profile = UserProfile.objects.get(user=existing_user)

                    # Update grade and supervisor details
                    # This code is dup[licated]
                    if "grade" in user:
                        if not user["grade"].startswith("ST"):
                            user["grade"] = f"ST{user['grade']}"

                        grade = UserGrades.objects.get(name=user["grade"])
                        user_profile.grade = grade

                    if "supervisor_name" in user and user.get("supervisor_name"):
                        sup_email = user.get("supervisor_email")
                        # If supervisor email provided, prefer that. Otherwise try to match by name or create placeholder
                        if sup_email and sup_email != 'undefined':
                            s, created = Supervisor.objects.get_or_create(email=sup_email, defaults={"name": user.get("supervisor_name")})
                        else:
                            # try match by name
                            s_qs = Supervisor.objects.filter(name__iexact=user.get("supervisor_name"))
                            if s_qs.exists():
                                s = s_qs.first()
                                created = False
                            else:
                                import uuid
                                placeholder = f"no-email-{uuid.uuid4().hex}@local.invalid"
                                s = Supervisor.objects.create(email=placeholder, name=user.get("supervisor_name"))
                                created = True

                        if created:
                            s.save()

                        user_profile.supervisor = s
                    user_profile.save()
                except User.DoesNotExist:
                    # Start by checking the email
                    try:
                        validate_email(user["email"])
                    except ValidationError:
                        error_text = (
                            error_text
                            + f"<p>{user['email']} does not appear to be a valid email (account for {user['first_name']} {user['last_name']} not created).</p>"
                        )
                        continue

                    # Try to create the user
                    try:
                        user_dict = {
                            "username": user["email"],
                            "first_name": user["first_name"],
                            "last_name": user["last_name"],
                            "email": user["email"],
                            "password": secrets.token_hex(nbytes=16),
                        }
                        new_user = User.objects.create_user(**user_dict)
                    except Exception as error:
                        error_text = (
                            error_text
                            + f"<p>Error creating user: {user['email']}<br/>{error}</p>"
                        )
                        # No need to try and create a profile if we can't create a user
                        continue

                    try:
                        user_profile = UserProfile.objects.get(user=new_user)
                        user_profile.peninsula_trainee = True
                        # TODO: check supervisor details are correct
                        if "supervisor_name" in user and user.get("supervisor_name"):
                            sup_email = user.get("supervisor_email")
                            if sup_email and sup_email != 'undefined':
                                s, created = Supervisor.objects.get_or_create(email=sup_email, defaults={"name": user.get("supervisor_name")})
                            else:
                                s_qs = Supervisor.objects.filter(name__iexact=user.get("supervisor_name"))
                                if s_qs.exists():
                                    s = s_qs.first()
                                    created = False
                                else:
                                    import uuid
                                    placeholder = f"no-email-{uuid.uuid4().hex}@local.invalid"
                                    s = Supervisor.objects.create(email=placeholder, name=user.get("supervisor_name"))
                                    created = True

                            if created:
                                s.save()

                            user_profile.supervisor = s

                        if "grade" in user:
                            if not user["grade"].startswith("ST"):
                                user["grade"] = f"ST{user['grade']}"

                            grade = UserGrades.objects.get(name=user["grade"])
                            user_profile.grade = grade

                        user_profile.save()

                        created_users.append(user["email"])
                    except Exception as error:
                        # If we fail to create the profile delete the user
                        new_user.delete()
                        error_text = (
                            error_text
                            + f"<p>Error creating user profile: {user['email']}<br/>{error} (user not created)</p>"
                        )

        except Exception as error:
            error_text = error_text + f"<p>Error creating users.<br/>{error}</p>"

        context["error"] = mark_safe(error_text)
        context["created_users"] = created_users

        if existing_users:
            context["message"] = "The following users already exist: " + ", ".join(
                existing_users
            )

        return render(request, "accounts_bulk_create.html", context)
    else:
        return render(request, "accounts_bulk_create.html", {})


def request_cid_details(request):
    email = request.POST.get("email")
    try:
        validate_email(email)
    except ValidationError:
        return HttpResponse("Invalid email.")

    cid_users = CidUser.objects.filter(email=email)

    for cid_user in cid_users:
        cid_user.email_details(resend=True)
        cid_user.email_details()

    return HttpResponse(
        f"Candidate details will be sent to the requested email (if it is found in the system). If you have not received an email after a few minutes you may need to contact <a href='mailto:{settings.CONTACT_EMAIL}'>{settings.CONTACT_EMAIL}</a>"
    )


def cimar_study_dicom_json(request, uuid="c9417b53-87aa-4c40-aca0-3fa34c225536"):
    with CimarAPI(request.user.userprofile.cimar_sid) as api:
        # studies = api.list_studies()
        # test_study = studies["studies"][0]

        # schema = api.get_study_schema(test_study)

        schema = api.get_study_schema_by_uuid("c9417b53-87aa-4c40-aca0-3fa34c225536")

        return JsonResponse(api.get_study_dicom_json(schema))


def cimar_study_viewer(request, uuid="c9417b53-87aa-4c40-aca0-3fa34c225536"):
    case = get_object_or_404(CimarCase, uuid=uuid)

    viewer_link = case.viewer_link + f"?sid={request.user.userprofile.cimar_sid}"
    return render(request, "cimar_embed.html", {"viewer_link": viewer_link})


def cimar_study_viewer_embed(request, uuid="c9417b53-87aa-4c40-aca0-3fa34c225536"):
    case = get_object_or_404(CimarCase, uuid=uuid)

    viewer_link = case.viewer_link + f"?sid={request.user.userprofile.cimar_sid}"
    return render(request, "cimar_embed.html#embed", {"viewer_link": viewer_link})


def cimar_study_series_block(request, uuid):
    case = get_object_or_404(CimarCase, uuid=uuid)

    return render(
        request,
        "cimar_series.html",
        {
            "series_data": case.series_data["series"],
            "cimar_sid": request.user.userprofile.cimar_sid,
        },
    )


def cimar_status(request):
    login_status = CimarAPI(request.user.userprofile.cimar_sid).check_login_status()

    if login_status:
        return HttpResponse("")
    else:
        return render(
            request,
            "cimar_login.html#login-block",
            {
                "login_status": login_status,
                "cimar_sid": request.user.userprofile.cimar_sid,
            },
        )


def cimar_logout(request):
    CimarAPI(request.user.userprofile.cimar_sid).logout()
    return HttpResponse("Logged out")


def cimar_login(request):
    if request.htmx:
        username = request.POST.get("username")
        password = request.POST.get("password")

        if not username and not password:
            return HttpResponse("Please fill in login details")

        try:
            sid = CimarAPI().login(username, password)

            request.user.userprofile.cimar_sid = sid
            request.user.userprofile.save()
        except InvalidCredentials:
            return HttpResponse("Invalid login details")

        return HttpResponse("Logged in")

    else:
        try:
            login_status = CimarAPI(
                request.user.userprofile.cimar_sid
            ).check_login_status()
        except NoSession:
            login_status = False
        return render(
            request,
            "cimar_login.html",
            {
                "login_status": login_status,
                "cimar_sid": request.user.userprofile.cimar_sid,
            },
        )