Function bodies 261 total

    public PapsGrade calculate(String subItem, String rawValue, Gender gender, Integer studentGrade) {
        if (subItem == null || rawValue == null || gender == null) return null;
        Double value = extractNumber(rawValue);
        if (value == null) return null;

        // 학년 보정: 1/2/3 범위 밖은 고1로 간주
        int g = (studentGrade != null && studentGrade >= 1 && studentGrade <= 3) ? studentGrade : 1;
        boolean male = (gender == Gender.MALE);
        String item = subItem.trim();

        // ==== 심폐지구력: 왕복오래달리기(20m 셔틀런, 회) — 오름차순 ====
        if (item.contains("왕복오래달리기") || item.contains("셔틀런")) {
            if (male) {
                if (g == 1) return ascFail(value, 16, 26, 42, 56, 70);
                if (g == 2) return ascFail(value, 16, 28, 44, 58, 72);
                return ascFail(value, 18, 30, 46, 60, 74); // 고3
            } else {
                if (g == 1) return ascFail(value, 13, 17, 25, 37, 50);
                return ascFail(value, 14, 18, 27, 41, 55); //

    private PapsGrade ascFail(double v, double failBoundary,
                               double t4min, double t3min, double t2min, double t1min) {
        if (v < failBoundary) return PapsGrade.FAIL;
        if (v >= t1min) return PapsGrade.GRADE_1;
        if (v >= t2min) return PapsGrade.GRADE_2;
        if (v >= t3min) return PapsGrade.GRADE_3;
        if (v >= t4min) return PapsGrade.GRADE_4;
        return PapsGrade.GRADE_5;
    }

    private PapsGrade descFail(double v, double t1max, double t2max, double t3max, double t4max,
                                double failBoundary) {
        if (v > failBoundary) return PapsGrade.FAIL;
        if (v <= t1max) return PapsGrade.GRADE_1;
        if (v <= t2max) return PapsGrade.GRADE_2;
        if (v <= t3max) return PapsGrade.GRADE_3;
        if (v <= t4max) return PapsGrade.GRADE_4;
        return PapsGrade.GRADE_5;
    }

    private PapsGrade bmi(double v, double leanMax, double normalMax, double overMax, double mildMax) {
        if (v <= leanMax) return PapsGrade.BMI_LEAN;
        if (v <= normalMax) return PapsGrade.BMI_NORMAL;
        if (v <= overMax) return PapsGrade.BMI_OVERWEIGHT;
        if (v <= mildMax) return PapsGrade.BMI_MILD_OBESE;
        return PapsGrade.BMI_SEVERE_OBESE;
    }

    private PapsGrade bmiNoOver(double v, double leanMax, double normalMax, double mildMax) {
        if (v <= leanMax) return PapsGrade.BMI_LEAN;
        if (v <= normalMax) return PapsGrade.BMI_NORMAL;
        if (v <= mildMax) return PapsGrade.BMI_MILD_OBESE;
        return PapsGrade.BMI_SEVERE_OBESE;
    }

    private Double extractNumber(String raw) {
        if (raw == null) return null;
        StringBuilder sb = new StringBuilder();
        boolean dotUsed = false;
        for (char c : raw.toCharArray()) {
            if (Character.isDigit(c)) sb.append(c);
            else if (c == '.' && !dotUsed) { sb.append(c); dotUsed = true; }
            else if (c == '-' && sb.length() == 0) sb.append(c); // 음수 허용 (유연성 종목)
            else if (sb.length() > 0) break;
        }
        if (sb.length() == 0 || sb.toString().equals("-")) return null;
        try {
            return Double.parseDouble(sb.toString());
        } catch (NumberFormatException e) {
            return null;
        }
    }

public class PapsService {

    private final PapsRepository papsRepository;
    private final StudentRepository studentRepository;
    private final PapsGradeCalculator gradeCalculator;

    public PapsService(PapsRepository papsRepository, StudentRepository studentRepository,
                       PapsGradeCalculator gradeCalculator) {
        this.papsRepository = papsRepository;
        this.studentRepository = studentRepository;
        this.gradeCalculator = gradeCalculator;
    }

    /** 학생별 PAPS 기록 조회 */
    public List<Paps> findByStudent(Long studentId) {
        Student s = studentRepository.findById(studentId)
            .orElseThrow(() -> new IllegalArgumentException("학생 없음"));
        return papsRepository.findByStudentOrderByYearDesc(s);
    }

    public Paps findById(Long id) {
        return papsRepository.findById(id)
            .orElseThrow(() -> new IllegalArgumentException("PAPS 기록 없음"));
    }

    @Transactional
    public Paps create(Paps paps, Long student

    public PapsService(PapsRepository papsRepository, StudentRepository studentRepository,
                       PapsGradeCalculator gradeCalculator) {
        this.papsRepository = papsRepository;
        this.studentRepository = studentRepository;
        this.gradeCalculator = gradeCalculator;
    }

    public List<Paps> findByStudent(Long studentId) {
        Student s = studentRepository.findById(studentId)
            .orElseThrow(() -> new IllegalArgumentException("학생 없음"));
        return papsRepository.findByStudentOrderByYearDesc(s);
    }

    public Paps findById(Long id) {
        return papsRepository.findById(id)
            .orElseThrow(() -> new IllegalArgumentException("PAPS 기록 없음"));
    }

    public Paps create(Paps paps, Long studentId) {
        Student s = studentRepository.findById(studentId)
            .orElseThrow(() -> new IllegalArgumentException("학생 없음"));
        paps.setStudent(s);
        // 등급이 비어있으면 세부종목+측정값+성별로 자동 계산
        autoGradeIfEmpty(paps, s);
        return papsRepository.save(paps);
    }

    public Paps update(Long id, Paps updated) {
        Paps existing = findById(id);
        existing.setCategory(updated.getCategory());
        existing.setSubItem(updated.getSubItem());
        existing.setMeasureValue(updated.getMeasureValue());
        existing.setPapsGrade(updated.getPapsGrade());
        existing.setYear(updated.getYear());
        // 등급이 비어있으면 자동 계산
        autoGradeIfEmpty(existing, existing.getStudent());
        return existing;
    }

    private void autoGradeIfEmpty(Paps paps, Student student) {
        com.yumi.yumiclass.enums.PapsGrade calc = gradeCalculator.calculate(
            paps.getSubItem(), paps.getMeasureValue(), student.getGender(), student.getGrade());
        paps.setPapsGrade(calc != null ? calc : com.yumi.yumiclass.enums.PapsGrade.GRADE_3);
    }

    public void delete(Long id) {
        papsRepository.deleteById(id);
    }

public class ScoreService {

    private final ScoreRepository scoreRepository;
    private final StudentRepository studentRepository;
    private final SportItemRepository sportItemRepository;

    public ScoreService(ScoreRepository scoreRepository,
                        StudentRepository studentRepository,
                        SportItemRepository sportItemRepository) {
        this.scoreRepository = scoreRepository;
        this.studentRepository = studentRepository;
        this.sportItemRepository = sportItemRepository;
    }

    /**
     * 반/종목/학기/연도 단위로 학생별 기존 점수 조회
     */
    public Map<Student, Score> getClassScores(Integer grade, Integer classNum,
                                              Long sportItemId, Integer year, Semester semester) {
        // 학생 목록 조회 (학년/반 필터는 선택)
        // - 학년+반: 해당 반
        // - 학년만: 해당 학년 전체
        // - 학년 없음: 전체 학생
        List<Student> students;
        if (grade != null && classNum != null) {
            students = studentReposi

    public ScoreService(ScoreRepository scoreRepository,
                        StudentRepository studentRepository,
                        SportItemRepository sportItemRepository) {
        this.scoreRepository = scoreRepository;
        this.studentRepository = studentRepository;
        this.sportItemRepository = sportItemRepository;
    }

    public Map<Student, Score> getClassScores(Integer grade, Integer classNum,
                                              Long sportItemId, Integer year, Semester semester) {
        // 학생 목록 조회 (학년/반 필터는 선택)
        // - 학년+반: 해당 반
        // - 학년만: 해당 학년 전체
        // - 학년 없음: 전체 학생
        List<Student> students;
        if (grade != null && classNum != null) {
            students = studentRepository.findByGradeAndClassNumOrderByNumberAsc(grade, classNum);
        } else if (grade != null) {
            students = studentRepository.findByGradeOrderByClassNumAscNumberAsc(grade);
        } else {
            students = studentRepository.findAll(
                org.springframework.data.domain.Sort.by("grade", "classNum", "number"));
        }
        if (students.isEmpty()) return Collections.emptyMap();

        Map<Student, Score> result = new LinkedHashMap<>();
        for (Student s : students) {
            // 종목이 선택된 경우만 해당 종목 점수 매핑
            Score existing = null;
       

    public int saveBatch(Long sportItemId, Integer year, Semester semester,
                         Map<Long, Integer> scoreMap, Map<Long, String> gradeMap,
                         Map<Long, String> remarksMap) {
        SportItem item = sportItemRepository.findById(sportItemId)
            .orElseThrow(() -> new IllegalArgumentException("종목 없음"));

        int saved = 0;
        for (Map.Entry<Long, Integer> e : scoreMap.entrySet()) {
            Long studentId = e.getKey();
            Integer scoreValue = e.getValue();
            if (scoreValue == null) continue;

            Student student = studentRepository.findById(studentId).orElse(null);
            if (student == null) continue;

            // 기존 기록 찾기
            Score score = scoreRepository.findByStudentAndYearAndSemester(student, year, semester).stream()
                .filter(sc -> sc.getSportItem().getId().equals(sportItemId))
                .findFirst()
                .orElseGet(() -> {
                    Scor

    public List<Score> findByClass(Integer grade, Integer classNum) {
        return scoreRepository.findByStudentGradeAndStudentClassNum(grade, classNum);
    }

public class StatsService {

    private final StudentRepository studentRepository;
    private final AttendanceRepository attendanceRepository;
    private final LeagueRepository leagueRepository;
    private final AssignmentRepository assignmentRepository;
    private final AssignmentSubmitRepository assignmentSubmitRepository;

    public StatsService(StudentRepository studentRepository,
                        AttendanceRepository attendanceRepository,
                        LeagueRepository leagueRepository,
                        AssignmentRepository assignmentRepository,
                        AssignmentSubmitRepository assignmentSubmitRepository) {
        this.studentRepository = studentRepository;
        this.attendanceRepository = attendanceRepository;
        this.leagueRepository = leagueRepository;
        this.assignmentRepository = assignmentRepository;
        this.assignmentSubmitRepository = assignmentSubmitRepository;
    }

    /** 전체 학생 수 */
    public long ge

    public StatsService(StudentRepository studentRepository,
                        AttendanceRepository attendanceRepository,
                        LeagueRepository leagueRepository,
                        AssignmentRepository assignmentRepository,
                        AssignmentSubmitRepository assignmentSubmitRepository) {
        this.studentRepository = studentRepository;
        this.attendanceRepository = attendanceRepository;
        this.leagueRepository = leagueRepository;
        this.assignmentRepository = assignmentRepository;
        this.assignmentSubmitRepository = assignmentSubmitRepository;
    }

    public long getTotalStudents() {
        return studentRepository.count();
    }

    public long getTodayAttendanceCount() {
        return attendanceRepository.findByAttendanceDate(LocalDate.now()).size();
    }

    public long getTotalLeagues() {
        return leagueRepository.count();
    }

    public long getTotalAssignments() {
        return assignmentRepository.count();
    }

    public Map<String, Long> getTodayAttendanceDistribution() {
        List<Attendance> todayList = attendanceRepository.findByAttendanceDate(LocalDate.now());
        Map<String, Long> dist = new LinkedHashMap<>();
        // 모든 상태를 0으로 초기화 (데이터 없어도 범례 유지)
        for (AttendanceStatus s : AttendanceStatus.values()) {
            dist.put(s.getDisplayName(), 0L);
        }
        for (Attendance a : todayList) {
            String key = a.getStatus().getDisplayName();
            dist.merge(key, 1L, Long::sum);
        }
        return dist;
    }

    public Map<String, Long> getRecent7DaysAttendanceTrend() {
        Map<String, Long> trend = new LinkedHashMap<>();
        DateTimeFormatter fmt = DateTimeFormatter.ofPattern("MM-dd");
        LocalDate today = LocalDate.now();
        // 6일 전부터 오늘까지 7개 날짜
        for (int i = 6; i >= 0; i--) {
            LocalDate d = today.minusDays(i);
            long count = attendanceRepository.findByAttendanceDate(d).size();
            trend.put(d.format(fmt), count);
        }
        return trend;
    }

    public Map<String, Long> getStudentCountByGrade() {
        Map<String, Long> map = new LinkedHashMap<>();
        map.put("1학년", 0L);
        map.put("2학년", 0L);
        map.put("3학년", 0L);
        List<Student> all = studentRepository.findAll();
        for (Student s : all) {
            if (s.getEnabled() != null && !s.getEnabled()) continue;
            Integer g = s.getGrade();
            if (g == null) continue;
            String key = g + "학년";
            map.merge(key, 1L, Long::sum);
        }
        return map;
    }

    public int getTodayAttendanceRate() {
        List<Attendance> todayList = attendanceRepository.findByAttendanceDate(LocalDate.now());
        if (todayList.isEmpty()) return 0;
        long present = todayList.stream()
            .filter(a -> a.getStatus() == AttendanceStatus.PRESENT)
            .count();
        return (int) Math.round(present * 100.0 / todayList.size());
    }

    public int getTodayAttendanceInputRate() {
        long total = studentRepository.count();
        if (total == 0) return 0;
        long today = attendanceRepository.findByAttendanceDate(LocalDate.now()).size();
        int rate = (int) Math.round(today * 100.0 / total);
        return Math.min(rate, 100);
    }

    public int getAssignmentSubmitRate() {
        long totalAssignments = assignmentRepository.count();
        long totalStudents = studentRepository.count();
        if (totalAssignments == 0 || totalStudents == 0) return 0;
        long submitted = assignmentSubmitRepository.count();
        long expected = totalAssignments * totalStudents;
        int rate = (int) Math.round(submitted * 100.0 / expected);
        return Math.min(rate, 100);
    }

public class StudentDashboardService {

    private final StudentRepository studentRepository;
    private final AttendanceRepository attendanceRepository;
    private final ScoreRepository scoreRepository;
    private final PapsRepository papsRepository;
    private final AssignmentRepository assignmentRepository;
    private final AssignmentSubmitRepository assignmentSubmitRepository;
    private final LeagueRepository leagueRepository;

    public StudentDashboardService(StudentRepository studentRepository,
                                   AttendanceRepository attendanceRepository,
                                   ScoreRepository scoreRepository,
                                   PapsRepository papsRepository,
                                   AssignmentRepository assignmentRepository,
                                   AssignmentSubmitRepository assignmentSubmitRepository,
                                   LeagueRepository leagueRepository) {
        this.studentRepository =

    public StudentDashboardService(StudentRepository studentRepository,
                                   AttendanceRepository attendanceRepository,
                                   ScoreRepository scoreRepository,
                                   PapsRepository papsRepository,
                                   AssignmentRepository assignmentRepository,
                                   AssignmentSubmitRepository assignmentSubmitRepository,
                                   LeagueRepository leagueRepository) {
        this.studentRepository = studentRepository;
        this.attendanceRepository = attendanceRepository;
        this.scoreRepository = scoreRepository;
        this.papsRepository = papsRepository;
        this.assignmentRepository = assignmentRepository;
        this.assignmentSubmitRepository = assignmentSubmitRepository;
        this.leagueRepository = leagueRepository;
    }

    public Student findStudent(String username) {
        return studentRepository.findByUsername(username)
            .orElseThrow(() -> new IllegalArgumentException("학생 없음: " + username));
    }

    public DashboardSummary getSummary(Student student) {
        DashboardSummary d = new DashboardSummary();
        d.studentName = student.getName();
        d.grade = student.getGrade();
        d.classNum = student.getClassNum();
        d.number = student.getNumber();

        // === 출결 통계 ===
        // 본인 출결 전체 조회 후 상태별 카운트
        List<Attendance> attendances = attendanceRepository.findByStudentOrderByAttendanceDateDesc(student);
        d.totalDays = attendances.size();
        d.presentCount = (int) attendances.stream()
            .filter(a -> a.getStatus() == AttendanceStatus.PRESENT).count();
        d.lateCount = (int) attendances.stream()
            .filter(a -> a.getStatus() == AttendanceStatus.LATE).count();
        d.absentCount = (int) attendances.stream()
            .filter(a -> a.getStatus() == AttendanceStatus.ABSENT).count();
        d.earlyLeaveCount = (int) attendances.stream()
            .filter(a -> a.getStatus() == AttendanceStatus.EARLY_LEAVE).count();

    public static class DashboardSummary {
        // 학생 기본 정보
        public String studentName;
        public Integer grade;
        public Integer classNum;
        public Integer number;

        // 출결
        public int totalDays;
        public int presentCount;
        public int lateCount;
        public int absentCount;
        public int earlyLeaveCount;
        public double attendanceRate; // 출석률 %

        // 점수
        public int scoreCount;
        public double averageScore;
        public List<Score> recentScores;

        // PAPS
        public int papsCount;
        public List<Paps> recentPaps;

        // 과제
        public int totalAssignments;
        public int submittedCount;
        public int pendingCount;

        // 대회
        public int leagueCount;
        public List<League> recentLeagues;

        // Getters (Thymeleaf 접근용)
        public String getStudentName() { return studentName; }
        public Integer getGrade() { return grade; }
        public I

public class StudentPageService {

    private final ScoreRepository scoreRepository;
    private final PapsRepository papsRepository;
    private final AssignmentRepository assignmentRepository;
    private final AssignmentSubmitRepository assignmentSubmitRepository;
    private final LeagueRepository leagueRepository;

    public StudentPageService(ScoreRepository scoreRepository,
                              PapsRepository papsRepository,
                              AssignmentRepository assignmentRepository,
                              AssignmentSubmitRepository assignmentSubmitRepository,
                              LeagueRepository leagueRepository) {
        this.scoreRepository = scoreRepository;
        this.papsRepository = papsRepository;
        this.assignmentRepository = assignmentRepository;
        this.assignmentSubmitRepository = assignmentSubmitRepository;
        this.leagueRepository = leagueRepository;
    }

    /** 본인 체육 점수 전체 (최신순) */
    public List<Scor

    public StudentPageService(ScoreRepository scoreRepository,
                              PapsRepository papsRepository,
                              AssignmentRepository assignmentRepository,
                              AssignmentSubmitRepository assignmentSubmitRepository,
                              LeagueRepository leagueRepository) {
        this.scoreRepository = scoreRepository;
        this.papsRepository = papsRepository;
        this.assignmentRepository = assignmentRepository;
        this.assignmentSubmitRepository = assignmentSubmitRepository;
        this.leagueRepository = leagueRepository;
    }

    public List<Score> getScores(Student student) {
        return scoreRepository.findByStudentOrderByYearDescSemesterDesc(student);
    }

    public List<Paps> getPaps(Student student) {
        return papsRepository.findByStudentOrderByYearDesc(student);
    }

    public List<AssignmentView> getAssignments(Student student) {
        List<Assignment> all = assignmentRepository
            .findByTargetGradeOrderByDueDateDesc(student.getGrade());
        List<AssignmentView> result = new ArrayList<>();
        for (Assignment a : all) {
            Optional<AssignmentSubmit> submit = assignmentSubmitRepository
                .findByAssignmentAndStudent(a, student);
            AssignmentView view = new AssignmentView();
            view.assignment = a;
            view.submitted = submit.isPresent();
            view.submittedContent = submit.map(AssignmentSubmit::getContent).orElse("");
            view.submittedAt = submit.map(AssignmentSubmit::getSubmittedAt).orElse(null);
            result.add(view);
        }
        return result;
    }

    public void submitAssignment(Student student, Long assignmentId, String content) {
        Assignment assignment = assignmentRepository.findById(assignmentId)
            .orElseThrow(() -> new IllegalArgumentException("과제 없음: " + assignmentId));
        // 본인 학년에 해당하는 과제만 제출 가능 (권한 방어)
        if (!assignment.getTargetGrade().equals(student.getGrade())) {
            throw new IllegalArgumentException("해당 과제는 본인 학년 대상이 아닙니다.");
        }
        AssignmentSubmit submit = assignmentSubmitRepository
            .findByAssignmentAndStudent(assignment, student)
            .orElseGet(() -> {
                AssignmentSubmit s = new AssignmentSubmit();
                s.setAssignment(assignment);
                s.setStudent(student);
                return s;
            });
        submit.setContent(content != null ? content.trim() : "");
        submit.setSubmittedAt(LocalDateTime.now());
        assignmentSubmitRepository.save(submit);
    }

    public List<League> getLeagues(Student student) {
        return leagueRepository
            .findByGradeAndClassNumOrderByCreatedAtDesc(student.getGrade(), student.getClassNum());
    }

    public static class AssignmentView {
        public Assignment assignment;
        public boolean submitted;
        public String submittedContent;
        public LocalDateTime submittedAt;

        public Assignment getAssignment() { return assignment; }
        public boolean isSubmitted() { return submitted; }
        public String getSubmittedContent() { return submittedContent; }
        public LocalDateTime getSubmittedAt() { return submittedAt; }
    }

public class StudentService {

    private final StudentRepository studentRepository;
    private final PasswordEncoder passwordEncoder;

    public StudentService(StudentRepository studentRepository, PasswordEncoder passwordEncoder) {
        this.studentRepository = studentRepository;
        this.passwordEncoder = passwordEncoder;
    }

    /** 학생 전체 목록 (학년/반/번호순) */
    public List<Student> findAll() {
        return studentRepository.findAll(
            org.springframework.data.domain.Sort.by("grade", "classNum", "number"));
    }

    /** ID로 단건 조회 */
    public Student findById(Long id) {
        return studentRepository.findById(id)
            .orElseThrow(() -> new IllegalArgumentException("학생을 찾을 수 없습니다: " + id));
    }

    /** 학년/반별 학생 조회 */
    public List<Student> findByGradeAndClass(Integer grade, Integer classNum) {
        return studentRepository.findByGradeAndClassNumOrderByNumberAsc(grade, classNum);
    }

    /** 학년별 학생 조회 (반/번호순) */
    public List<Student> fi

    public StudentService(StudentRepository studentRepository, PasswordEncoder passwordEncoder) {
        this.studentRepository = studentRepository;
        this.passwordEncoder = passwordEncoder;
    }

    public List<Student> findAll() {
        return studentRepository.findAll(
            org.springframework.data.domain.Sort.by("grade", "classNum", "number"));
    }

    public Student findById(Long id) {
        return studentRepository.findById(id)
            .orElseThrow(() -> new IllegalArgumentException("학생을 찾을 수 없습니다: " + id));
    }

    public List<Student> findByGradeAndClass(Integer grade, Integer classNum) {
        return studentRepository.findByGradeAndClassNumOrderByNumberAsc(grade, classNum);
    }

    public List<Student> findByGrade(Integer grade) {
        return studentRepository.findByGradeOrderByClassNumAscNumberAsc(grade);
    }