#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys


def main():
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "Couldn't import Django. Is it installed and available on your "
            "PYTHONPATH environment variable? Did you forget to activate a "
            "virtual environment?"
        ) from exc
    execute_from_command_line(sys.argv)


if __name__ == "__main__":
    main()

urlpatterns = [
    path("admin/", admin.site.urls),
    path("api/auth/login/", TokenObtainPairView.as_view(), name="token_obtain_pair"),
    path("api/auth/token/refresh/", TokenRefreshView.as_view(), name="token_refresh"),
    path("api/auth/", include("apps.accounts.urls")),
    path("api/", include("apps.problems.urls")),
    path("api/submissions/", include("apps.submissions.urls")),
]

from django.apps import AppConfig

class AccountsConfig(AppConfig):
    default_auto_field = "django.db.models.BigAutoField"
    name = "apps.accounts"
    label = "accounts"

from django.contrib.auth.models import AbstractUser
from django.db import models


class User(AbstractUser):
    class Role(models.TextChoices):
        USER = "user", "普通用户"
        ADMIN = "admin", "管理员"

    role = models.CharField(max_length=20, choices=Role.choices, default=Role.USER)
    solved_count = models.PositiveIntegerField(default=0)
    submit_count = models.PositiveIntegerField(default=0)

    @property
    def is_admin(self):
        return self.role == self.Role.ADMIN or self.is_staff

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin

from .models import User

@admin.register(User)
class CustomUserAdmin(UserAdmin):
    fieldsets = UserAdmin.fieldsets + (
        ("OJ 信息", {"fields": ("role", "solved_count", "submit_count")}),
    )
    list_display = ("id", "username", "email", "role", "is_staff", "is_active")
    list_filter = ("role", "is_staff", "is_active")

from django.contrib.auth import get_user_model
from rest_framework import serializers

User = get_user_model()


class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ("id", "username", "email", "role", "solved_count", "submit_count")


class RegisterSerializer(serializers.ModelSerializer):
    password = serializers.CharField(write_only=True, min_length=6)

    class Meta:
        model = User
        fields = ("id", "username", "email", "password")

    def create(self, validated_data):
        return User.objects.create_user(**validated_data)

from rest_framework import generics
from rest_framework.permissions import AllowAny, IsAuthenticated

from .serializers import RegisterSerializer, UserSerializer


class RegisterView(generics.CreateAPIView):
    serializer_class = RegisterSerializer
    permission_classes = [AllowAny]


class MeView(generics.RetrieveAPIView):
    serializer_class = UserSerializer
    permission_classes = [IsAuthenticated]

    def get_object(self):
        return self.request.user

from django.urls import path

from .views import MeView, RegisterView

urlpatterns = [
    path("register/", RegisterView.as_view(), name="register"),
    path("me/", MeView.as_view(), name="me"),
]

path("api/auth/login/", TokenObtainPairView.as_view(), name="token_obtain_pair"),
path("api/auth/token/refresh/", TokenRefreshView.as_view(), name="token_refresh"),

class Tag(models.Model):
    name = models.CharField(max_length=40, unique=True)

    class Meta:
        ordering = ["name"]

    def __str__(self):
        return self.name

class Problem(models.Model):
    class Difficulty(models.TextChoices):
        EASY = "easy", "简单"
        MEDIUM = "medium", "中等"
        HARD = "hard", "困难"

    title = models.CharField(max_length=120)
    description = models.TextField()
    input_description = models.TextField(blank=True)
    output_description = models.TextField(blank=True)
    difficulty = models.CharField(
        max_length=20,
        choices=Difficulty.choices,
        default=Difficulty.EASY,
    )
    time_limit = models.PositiveIntegerField(default=2000, help_text="单位：ms")
    memory_limit = models.PositiveIntegerField(default=128, help_text="单位：MB")
    is_public = models.BooleanField(default=True)
    tags = models.ManyToManyField(Tag, blank=True, related_name="problems")
    created_by = models.ForeignKey(
    	settings.AUTH_USER_MODEL,
        null=True,
        blank=True,
        on_delete=models.SET_NULL,
        related_name="created_problems",
    )
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        ordering = ["id"]

    def __str__(self):
        return f"{self.id}. {self.title}"

class TestCase(models.Model):
    problem = models.ForeignKey(Problem, on_delete=models.CASCADE, related_name="test_cases")
    input_data = models.TextField(blank=True)
    output_data = models.TextField(blank=True)
    is_sample = models.BooleanField(default=False)
    score = models.PositiveIntegerField(default=0)
    order = models.PositiveIntegerField(default=0)

    class Meta:
        ordering = ["order", "id"]

    def __str__(self):
        return f"{self.problem_id} - case {self.id}"

class TestCaseInline(admin.TabularInline):
    model = TestCase
    extra = 1
    fields = ("order", "input_data", "output_data", "is_sample", "score")
@admin.register(Problem)
class ProblemAdmin(admin.ModelAdmin):
    list_display = ("id", "title", "difficulty", "is_public", "created_at")
    list_filter = ("difficulty", "is_public", "tags")
    search_fields = ("title", "description")
    filter_horizontal = ("tags",)
    inlines = [TestCaseInline]

    def save_model(self, request, obj, form, change):
        if not obj.created_by:
            obj.created_by = request.user
        super().save_model(request, obj, form, change)

@admin.register(Tag)
class TagAdmin(admin.ModelAdmin):
    list_display = ("id", "name")
    search_fields = ("name",)

@admin.register(TestCase)
class TestCaseAdmin(admin.ModelAdmin):
    list_display = ("id", "problem", "is_sample", "score", "order")
    list_filter = ("is_sample",)

class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
        fields = ("id", "name")

class SampleCaseSerializer(serializers.ModelSerializer):
    class Meta:
        model = TestCase
        fields = ("id", "input_data", "output_data", "order")

class ProblemListSerializer(serializers.ModelSerializer):
    tags = TagSerializer(many=True, read_only=True)

    class Meta:
        model = Problem
        fields = (
            "id",
            "title",
            "difficulty",
            "time_limit",
            "memory_limit",
            "tags",
        )

class ProblemDetailSerializer(serializers.ModelSerializer):
    tags = TagSerializer(many=True, read_only=True)
    tag_ids = serializers.PrimaryKeyRelatedField(
        source="tags",
        queryset=Tag.objects.all(),
        many=True,
        write_only=True,
        required=False,
    )
    sample_cases = serializers.SerializerMethodField()

    class Meta:
        model = Problem
        fields = (
            "id",
            "title",
            "description",
            "input_description",
            "output_description",
            "difficulty",
            "time_limit",
            "memory_limit",
            "is_public",
            "tags",
            "tag_ids",
            "sample_cases",
            "created_at",
            "updated_at",
        )
        read_only_fields = ("created_at", "updated_at")

    def get_sample_cases(self, obj):
        samples = obj.test_cases.filter(is_sample=True)
        return SampleCaseSerializer(samples, many=True).data

class TestCaseSerializer(serializers.ModelSerializer):
    class Meta:
        model = TestCase
        fields = ("id", "problem", "input_data", "output_data", "is_sample", "score", "order")

class ProblemViewSet(viewsets.ModelViewSet):
    permission_classes = [IsAdminOrReadOnly]
    filterset_fields = ("difficulty", "tags")
    search_fields = ("title", "description")
    ordering_fields = ("id", "created_at", "difficulty")

    def get_queryset(self):
        queryset = Problem.objects.prefetch_related("tags", "test_cases")
        user = self.request.user
        if not (user.is_authenticated and user.is_admin):
            queryset = queryset.filter(is_public=True)
        return queryset

    def get_serializer_class(self):
        if self.action == "list":
            return ProblemListSerializer
        return ProblemDetailSerializer

    def perform_create(self, serializer):
        serializer.save(created_by=self.request.user)

class TagViewSet(viewsets.ModelViewSet):
    queryset = Tag.objects.all()
    serializer_class = TagSerializer
    permission_classes = [IsAdminOrReadOnly]
    search_fields = ("name",)

class TestCaseViewSet(viewsets.ModelViewSet):
    serializer_class = TestCaseSerializer
    permission_classes = [IsAdminUser]

    def get_queryset(self):
        return TestCase.objects.select_related("problem")

from rest_framework.permissions import SAFE_METHODS, BasePermission

class IsAdminOrReadOnly(BasePermission):
    def has_permission(self, request, view):
        if request.method in SAFE_METHODS:
            return True
        return bool(request.user and request.user.is_authenticated and request.user.is_admin)

from rest_framework.routers import DefaultRouter

from .views import ProblemViewSet, TagViewSet, TestCaseViewSet

router = DefaultRouter()
router.register("problems", ProblemViewSet, basename="problem")
router.register("tags", TagViewSet, basename="tag")
router.register("test-cases", TestCaseViewSet, basename="test-case")

urlpatterns = router.urls

class Submission(models.Model):
    class Language(models.TextChoices):
        PYTHON3 = "python3", "Python 3"

    class Status(models.TextChoices):
        PENDING = "PENDING", "等待判题"
        JUDGING = "JUDGING", "正在判题"
        ACCEPTED = "ACCEPTED", "答案正确"
        WRONG_ANSWER = "WRONG_ANSWER", "答案错误"
        TIME_LIMIT_EXCEEDED = "TIME_LIMIT_EXCEEDED", "运行超时"
        RUNTIME_ERROR = "RUNTIME_ERROR", "运行错误"
        SYSTEM_ERROR = "SYSTEM_ERROR", "系统错误"

    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="submissions")
    problem = models.ForeignKey(Problem, on_delete=models.CASCADE, related_name="submissions")
    language = models.CharField(max_length=20, choices=Language.choices, default=Language.PYTHON3)
    code = models.TextField()
    status = models.CharField(max_length=30, choices=Status.choices, default=Status.PENDING)
    score = models.PositiveIntegerField(default=0)
    time_used = models.PositiveIntegerField(default=0, help_text="单位：ms")
    memory_used = models.PositiveIntegerField(default=0, help_text="单位：KB，初版可为空")
    error_message = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    judged_at = models.DateTimeField(null=True, blank=True)

    class Meta:
        ordering = ["-id"]

    def __str__(self):
        return f"#{self.id} {self.user} {self.problem} {self.status}"

class JudgeResult(models.Model):
    submission = models.ForeignKey(Submission, on_delete=models.CASCADE, related_name="results")
    testcase = models.ForeignKey(TestCase, on_delete=models.CASCADE, related_name="judge_results")
    status = models.CharField(max_length=30, choices=Submission.Status.choices)
    time_used = models.PositiveIntegerField(default=0)
    memory_used = models.PositiveIntegerField(default=0, help_text="单位：KB")
    output = models.TextField(blank=True)
    error_message = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["id"]

    def __str__(self):
        return f"submission {self.submission_id} case {self.testcase_id}: {self.status}"

class JudgeResultSerializer(serializers.ModelSerializer):
    class Meta:
        model = JudgeResult
        fields = ("id", "testcase", "status", "time_used", "memory_used", "output", "error_message")

class SubmissionCreateSerializer(serializers.ModelSerializer):
    problem = serializers.PrimaryKeyRelatedField(queryset=Problem.objects.filter(is_public=True))

    class Meta:
        model = Submission
        fields = ("id", "problem", "language", "code")

    def create(self, validated_data):
        user = self.context["request"].user
        user.submit_count += 1
        user.save(update_fields=["submit_count"])
        return Submission.objects.create(user=user, **validated_data)

class SubmissionReadSerializer(serializers.ModelSerializer):
    username = serializers.CharField(source="user.username", read_only=True)
    problem_title = serializers.CharField(source="problem.title", read_only=True)
    results = JudgeResultSerializer(many=True, read_only=True)

    class Meta:
        model = Submission
        fields = (
            "id",
            "username",
            "problem",
            "problem_title",
            "language",
            "code",
            "status",
            "score",
            "time_used",
            "memory_used",
            "error_message",
            "results",
            "created_at",
            "judged_at",
        )

class SubmissionViewSet(
    mixins.CreateModelMixin,
    mixins.ListModelMixin,
    mixins.RetrieveModelMixin,
    viewsets.GenericViewSet,
):
    permission_classes = [IsAuthenticated]
    filterset_fields = ("problem", "status", "language")
    ordering_fields = ("id", "created_at")

    def get_queryset(self):
        queryset = Submission.objects.select_related("user", "problem").prefetch_related("results")
        user = self.request.user
        if user.is_admin:
            return queryset
        return queryset.filter(user=user)

    def get_serializer_class(self):
        if self.action == "create":
            return SubmissionCreateSerializer
        return SubmissionReadSerializer

router = DefaultRouter()
router.register("", SubmissionViewSet, basename="submission")

urlpatterns = router.urls

@dataclass
class RunResult:
    status: str
    output: str = ""
    error_message: str = ""
    time_used: int = 0

def normalize_output(value):
    return value.replace("\r\n", "\n").strip()

def run_python_code(code, input_data, timeout_seconds):
    with tempfile.TemporaryDirectory() as temp_dir:
        code_path = Path(temp_dir) / "main.py"
        code_path.write_text(code, encoding="utf-8")

        started_at = time.perf_counter()
        try:
            completed = subprocess.run(
                [settings.JUDGE_PYTHON_COMMAND, str(code_path)],
                input=input_data,
                text=True,
                capture_output=True,
                timeout=timeout_seconds,
                cwd=temp_dir,
            )
        except subprocess.TimeoutExpired:
            time_used = int((time.perf_counter() - started_at) * 1000)
            return RunResult(status=Submission.Status.TIME_LIMIT_EXCEEDED, time_used=time_used)

        time_used = int((time.perf_counter() - started_at) * 1000)
        if completed.returncode != 0:
            return RunResult(
                status=Submission.Status.RUNTIME_ERROR,
                output=completed.stdout,
                error_message=completed.stderr[-2000:],
                time_used=time_used,
            )
        return RunResult(
            status=Submission.Status.ACCEPTED,
            output=completed.stdout,
            time_used=time_used,
        )

def judge_submission(submission):
    test_cases = list(submission.problem.test_cases.all())
    if not test_cases:
        submission.status = Submission.Status.SYSTEM_ERROR
        submission.error_message = "该题目没有测试点。"
        submission.judged_at = timezone.now()
        submission.save(update_fields=["status", "error_message", "judged_at"])
        return submission

    timeout_seconds = max(1, submission.problem.time_limit / 1000)
    total_score = 0
    max_time = 0
    final_status = Submission.Status.ACCEPTED
    final_error = ""

    JudgeResult.objects.filter(submission=submission).delete()

    for test_case in test_cases:
        run_result = run_python_code(submission.code, test_case.input_data, timeout_seconds)
        status = run_result.status

        if status == Submission.Status.ACCEPTED:
            if normalize_output(run_result.output) == normalize_output(test_case.output_data):
                total_score += test_case.score
            else:
                status = Submission.Status.WRONG_ANSWER

        JudgeResult.objects.create(
            submission=submission,
            testcase=test_case,
            status=status,
            time_used=run_result.time_used,
            memory_used=0,
            output=run_result.output[-2000:],
            error_message=run_result.error_message,
        )

        max_time = max(max_time, run_result.time_used)
        if status != Submission.Status.ACCEPTED:
            final_status = status
            final_error = run_result.error_message
            break

    submission.status = final_status
    submission.score = 100 if final_status == Submission.Status.ACCEPTED else total_score
    submission.time_used = max_time
    submission.error_message = final_error
    submission.judged_at = timezone.now()
    submission.save(
        update_fields=["status", "score", "time_used", "error_message", "judged_at"]
    )
    return submission

def process_next_submission():
    submission = acquire_pending_submission()
    if submission is None:
        return None
    return judge_submission(submission)

class Command(BaseCommand):
    help = "Run the simple KouOJ judge worker."

    def add_arguments(self, parser):
        parser.add_argument("--once", action="store_true", help="Only process one pending submission.")
        parser.add_argument("--sleep", type=float, default=1.0, help="Sleep seconds when queue is empty.")

    def handle(self, *args, **options):
        self.stdout.write(self.style.SUCCESS("Judge worker started."))
        while True:
            submission = process_next_submission()
            if submission:
                self.stdout.write(f"Judged submission #{submission.id}: {submission.status}")
            elif options["once"]:
                self.stdout.write("No pending submission.")
                return
            else:
                time.sleep(options["sleep"])

            if options["once"]:
                return

from django.conf import settings
from django.db import models


class OperationLog(models.Model):
    user = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name="operation_logs",
    )
    action = models.CharField(max_length=50)
    method = models.CharField(max_length=10)
    path = models.CharField(max_length=255)
    status_code = models.PositiveSmallIntegerField()

    ip_address = models.GenericIPAddressField(null=True, blank=True)
    user_agent = models.CharField(max_length=500, blank=True)

    object_type = models.CharField(max_length=50, blank=True)
    object_id = models.CharField(max_length=50, blank=True)
    detail = models.JSONField(default=dict, blank=True)

    duration_ms = models.PositiveIntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["-created_at"]
        indexes = [
            models.Index(fields=["user", "created_at"]),
            models.Index(fields=["action", "created_at"]),
            models.Index(fields=["status_code"]),
        ]

    def __str__(self):
        username = self.user.username if self.user else "anonymous"
        return f"{username} {self.action} {self.path}"

from django.contrib import admin

from .models import OperationLog


@admin.register(OperationLog)
class OperationLogAdmin(admin.ModelAdmin):
    list_display = (
        "id",
        "user",
        "action",
        "method",
        "path",
        "status_code",
        "duration_ms",
        "created_at",
    )
    list_filter = ("action", "method", "status_code", "created_at")
    search_fields = ("user__username", "path", "object_id")
    readonly_fields = (
        "user",
        "action",
        "method",
        "path",
        "status_code",
        "ip_address",
        "user_agent",
        "object_type",
        "object_id",
        "detail",
        "duration_ms",
        "created_at",
    )

import time

from rest_framework_simplejwt.authentication import JWTAuthentication

from .models import OperationLog


class OperationLogMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        started_at = time.perf_counter()

        response = self.get_response(request)

        duration_ms = int(
            (time.perf_counter() - started_at) * 1000
        )

        if self.should_record(request, response):
            self.create_log(request, response, duration_ms)

        return response
    # 记录需要的
    def should_record(self, request, response):
        if not request.path.startswith("/api/"):
            return False

        if request.path.startswith("/api/audit/"):
            return False

        write_methods = {"POST", "PUT", "PATCH", "DELETE"}

        return (
            request.method in write_methods
            or response.status_code >= 400
        )
    # 获得JWT用户
    def get_user(self, request):
        if request.user.is_authenticated:
            return request.user

        try:
            authentication = JWTAuthentication()
            result = authentication.authenticate(request)

            if result is not None:
                user, token = result
                return user
        except Exception:
            pass

        return None
    # 获取ip
    def get_ip_address(self, request):
        forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")

        if forwarded_for:
            return forwarded_for.split(",")[0].strip()

        return request.META.get("REMOTE_ADDR")
    # 生成操作名称
    def get_action(self, request):
        action_map = {
            "POST": "CREATE",
            "PUT": "UPDATE",
            "PATCH": "UPDATE",
            "DELETE": "DELETE",
        }

        if request.path == "/api/auth/login/":
            return "LOGIN"

        if request.path == "/api/auth/register/":
            return "REGISTER"

        if request.path == "/api/auth/change-password/":
            return "CHANGE_PASSWORD"

        if request.path == "/api/submissions/":
            return "CREATE_SUBMISSION"

        return action_map.get(request.method, "REQUEST_ERROR")
    # 创建日志
    def create_log(self, request, response, duration_ms):
        try:
            OperationLog.objects.create(
                user=self.get_user(request),
                action=self.get_action(request),
                method=request.method,
                path=request.path[:255],
                status_code=response.status_code,
                ip_address=self.get_ip_address(request),
                user_agent=request.META.get(
                    "HTTP_USER_AGENT",
                    "",
                )[:500],
                duration_ms=duration_ms,
                detail={
                    "query": request.GET.dict(),
                },
            )
        except Exception:
            # 日志失败不能影响正常业务请求
            pass

curl -H "Authorization: Bearer 你的access_token" `
  http://127.0.0.1:8000/api/submissions/1/