[COZY-669] feat : 일치율 계산 알고리즘 요구사항 변경 (#378)

* [COZY-669] feat: 일치율 계산기 인터페이스

* [COZY-669] feat: 정책에 따른 규칙별 감점계산 인터페이스

* [COZY-669] feat: 소음 관련 감점 계산기 구현

* [COZY-669] feat: 청결 관련 감점 계산기 구

* [COZY-669] feat: 생활패턴 관련 감점 계산기 구

* [COZY-669] feat: 성격 관련 감점 계산기 구

* [COZY-669] feat: 생활 환경 관련 감점 계산기 구

* [COZY-669] feat: 그룹을 정의하기 위한 enum클래스

* [COZY-669] feat: MemberStat Key를 위한 enum 클래스

* [COZY-669] add: 일치율 계산을 위한 헬퍼 메소드 추가

* [COZY-669] feat: MemberMatchRateCalculatorV2 구현

* [COZY-669] feat: MemberMatchRateCalculatorV2 구현

* [COZY-669] fix: MemberMatchRateCalculatorV2 적용

* [COZY-669] rename: 기존 계산기 삭제

* [COZY-669] chore: test 빌드를 위한 기존 테스트 코드 수정

* [COZY-669] test: 구현체 별 테스트 코드 추가

Author: genius00hwan

src/main/java/com/cozymate/cozymate_server/domain/memberstat/calculator/MatchRateCalculator.java

@@ -0,0 +1,7 @@
+package com.cozymate.cozymate_server.domain.memberstat.calculator;
+
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.Lifestyle;
+
+public interface MatchRateCalculator {
+    int calculateMatchRate(Lifestyle lifestyle1, Lifestyle lifestyle2);
+}

src/main/java/com/cozymate/cozymate_server/domain/memberstat/calculator/MemberMatchRateCalculatorV2.java

@@ -0,0 +1,39 @@
+package com.cozymate.cozymate_server.domain.memberstat.calculator;
+
+import com.cozymate.cozymate_server.domain.memberstat.calculator.penalty.Group;
+import com.cozymate.cozymate_server.domain.memberstat.calculator.penalty.PenaltyCalculator;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.Lifestyle;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class MemberMatchRateCalculatorV2 implements MatchRateCalculator {
+
+    private final Map<Group, PenaltyCalculator> chain;
+
+    public MemberMatchRateCalculatorV2(List<PenaltyCalculator> calculators) {
+        this.chain = calculators.stream()
+            .collect(Collectors.toMap(
+                PenaltyCalculator::getGroup,
+                c -> c,
+                (a, b) -> a,
+                () -> new EnumMap<>(Group.class)
+            ));
+    }
+
+    @Override
+    public int calculateMatchRate(Lifestyle a, Lifestyle b) {
+        double penalty = 0.0;
+        for (PenaltyCalculator calculator : chain.values()) {
+            penalty += calculator.calculatePenalty(a, b);
+//            log.info("{} 부분 계산 완료", calculator.group().name());
+        }
+        double score = 100.0 - penalty;
+        return (int) Math.round(Math.max(0.0, Math.min(100.0, score)));
+    }
+}

src/main/java/com/cozymate/cozymate_server/domain/memberstat/calculator/penalty/CharacterCalculator.java

@@ -0,0 +1,29 @@
+package com.cozymate.cozymate_server.domain.memberstat.calculator.penalty;
+
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.Lifestyle;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.enums.StatKey;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.util.QuestionAnswerMapper;
+import org.springframework.stereotype.Component;
+
+@Component
+public class CharacterCalculator implements PenaltyCalculator {
+
+    private static final double W_ITEM_SHARING = 4.0;
+    private static final double W_INTIMACY = 4.0;
+
+    private static final int GAP_ITEM_SHARING = QuestionAnswerMapper.gapOf(StatKey.SHARING_STATUS);
+    private static final int GAP_INTIMACY = QuestionAnswerMapper.gapOf(StatKey.INTIMACY);
+
+    @Override
+    public Group getGroup() {
+        return Group.D_CHARACTER;
+    }
+
+    @Override
+    public double calculatePenalty(Lifestyle a, Lifestyle b) {
+        double p = 0.0;
+        p += scoreDiff(a.getItemSharing(), b.getItemSharing(), GAP_ITEM_SHARING, W_ITEM_SHARING);
+        p += scoreDiff(a.getIntimacy(), b.getIntimacy(), GAP_INTIMACY, W_INTIMACY);
+        return p;
+    }
+}

src/main/java/com/cozymate/cozymate_server/domain/memberstat/calculator/penalty/CleannessCalculator.java

@@ -0,0 +1,54 @@
+package com.cozymate.cozymate_server.domain.memberstat.calculator.penalty;
+
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.Lifestyle;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.enums.StatKey;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.util.QuestionAnswerMapper;
+import org.springframework.stereotype.Component;
+
+@Component
+public class CleannessCalculator implements PenaltyCalculator {
+
+    private static final double WEIGHT_CLEAN_SENS = 10.0;
+    private static final double WEIGHT_EAT = 5.0;
+    private static final double WEIGHT_CLEAN_FREQ = 5.0;
+    private static final double WEIGHT_SMOKING = 2.0;
+
+    private static final int GAP_CLEAN_SENS = QuestionAnswerMapper.gapOf(StatKey.CLEANNESS_SENSITIVITY);
+    private static final int GAP_EAT = QuestionAnswerMapper.gapOf(StatKey.EATING_STATUS);
+    private static final int GAP_CLEAN_FREQ = QuestionAnswerMapper.gapOf(StatKey.CLEANING_FREQUENCY);
+
+    @Override
+    public Group getGroup() {
+        return Group.B_CLEANNESS;
+    }
+    @Override
+    public double calculatePenalty(Lifestyle a, Lifestyle b) {
+        double p = 0.0;
+        p += scoreDiff(a.getCleannessSensitivity(), b.getCleannessSensitivity(),
+            GAP_CLEAN_SENS, WEIGHT_CLEAN_SENS);
+
+        p += scoreDiff(a.getEatingFrequency(), b.getEatingFrequency(),
+            GAP_EAT, WEIGHT_EAT);
+
+        p += scoreDiff(a.getCleaningFrequency(), b.getCleaningFrequency(),
+            GAP_CLEAN_FREQ, WEIGHT_CLEAN_FREQ);
+
+        p += smokingPenaltyB(a.getSmokingStatus(), b.getSmokingStatus(),
+            WEIGHT_SMOKING);
+
+        return p;
+    }
+
+    /**
+     * 흡연 규칙 흡&흡 = 0, 비&비 = 0 - 흡&비: 연초=2, 전자담배=1
+     */
+    private double smokingPenaltyB(int x, int y, double weight) {
+        boolean isSmokeX = x != 0, isSmokeY = y != 0;
+        if ((isSmokeX && isSmokeY) || (!isSmokeX && !isSmokeY)) {
+            return 0.0;
+        }
+
+        int smoker = isSmokeX ? x : y;
+        return (smoker == 1) ? weight : weight / 2;
+    }
+}

src/main/java/com/cozymate/cozymate_server/domain/memberstat/calculator/penalty/Group.java

@@ -0,0 +1,5 @@
+package com.cozymate.cozymate_server.domain.memberstat.calculator.penalty;
+
+public enum Group {
+    A_NOISE, B_CLEANNESS, C_PATTERN, D_CHARACTER, E_ENV
+}

src/main/java/com/cozymate/cozymate_server/domain/memberstat/calculator/penalty/LifePatternCalculator.java

@@ -0,0 +1,33 @@
+package com.cozymate.cozymate_server.domain.memberstat.calculator.penalty;
+
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.Lifestyle;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.enums.StatKey;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.util.QuestionAnswerMapper;
+import org.springframework.stereotype.Component;
+
+@Component
+public class LifePatternCalculator implements PenaltyCalculator {
+
+    private static final double WEIGHT_WAKEUP = 10.0;
+    private static final double WEIGHT_TURN_OFF = 5.0;
+    private static final double WEIGHT_SLEEPING = 5.0;
+    private static final double WEIGHT_LIFE_PATTERN = 3.0;
+    private static final double WEIGHT_DRINKING = 2.0;
+    private static final int GAP_DRINKING = QuestionAnswerMapper.gapOf(StatKey.DRINKING_FREQUENCY);
+    @Override
+    public Group getGroup() {
+        return Group.C_PATTERN;
+    }
+    @Override
+    public double calculatePenalty(Lifestyle a, Lifestyle b) {
+        double p = 0.0;
+        p += scoreHour(a.getWakeUpTime(), b.getWakeUpTime(), WEIGHT_WAKEUP);
+        p += scoreHour(a.getTurnOffTime(), b.getTurnOffTime(), WEIGHT_TURN_OFF);
+        p += scoreHour(a.getSleepingTime(), b.getSleepingTime(), WEIGHT_SLEEPING);
+        p += scoreAnyDiff(a.getLifePattern(), b.getLifePattern(), WEIGHT_LIFE_PATTERN);
+        p += scoreDiff(a.getDrinkingFrequency(), b.getDrinkingFrequency(),
+            GAP_DRINKING, WEIGHT_DRINKING);
+        return p;
+    }
+
+}

src/main/java/com/cozymate/cozymate_server/domain/memberstat/calculator/penalty/LivingEnvironmentCalculator.java

@@ -0,0 +1,69 @@
+package com.cozymate.cozymate_server.domain.memberstat.calculator.penalty;
+
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.Lifestyle;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.enums.StatKey;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.util.QuestionAnswerMapper;
+import org.springframework.stereotype.Component;
+
+@Component
+public class LivingEnvironmentCalculator implements PenaltyCalculator {
+
+    private static final double WEIGHT_COOL = 3.0;
+    private static final double WEIGHT_SMOKING = 7.0;
+    private static final double WEIGHT_HEAT = 3.0;
+
+    private static final int GAP_COOL = QuestionAnswerMapper.gapOf(StatKey.COOLING_INTENSITY);
+    private static final int GAP_HEAT = QuestionAnswerMapper.gapOf(StatKey.HEATING_INTENSITY);
+
+    private static final double RATIO_VAPE = 2.0 / 7.0;
+    private static final double RATIO_IQOS = 4.0 / 7.0;
+    private static final double RATIO_CIGARETTE = 1.0;
+    private static final double RATIO_SMOKER_MISMATCH = 2.0 / 7.0;
+
+    @Override
+    public Group getGroup() {
+        return Group.E_ENV;
+    }
+    @Override
+    public double calculatePenalty(Lifestyle a, Lifestyle b) {
+        double p = 0.0;
+
+        p += smokingPenaltyE(a.getSmokingStatus(), b.getSmokingStatus());
+
+        p += scoreDiff(a.getCoolingIntensity(), b.getCoolingIntensity(), GAP_COOL, WEIGHT_COOL);
+        p += scoreDiff(a.getHeatingIntensity(), b.getHeatingIntensity(), GAP_HEAT, WEIGHT_HEAT);
+
+        return p;
+    }
+
+    /*
+     * 흡연(E) 규칙 (가중치 스케일링 버전)
+     * - 값: 0=비, 1=연초, 2=궐련형 전자담배(HNB), 3=액상형 전자담배
+     * - 비 & 비: 0점
+     * - 흡 & 흡: 타입이 다르면 2점(= weight * 2/7), 같으면 0점
+     * - 비 & 흡: 액=2/7, 궐=4/7, 연=1.0 비율로 weight에 비례해 감점
+     */
+    private double smokingPenaltyE(int x, int y) {
+        boolean h1 = x != 0, h2 = y != 0;
+
+        // 비 & 비
+        if (!h1 && !h2) {
+            return 0.0;
+        }
+
+        // 흡 & 흡
+        if (h1 && h2) {
+            return scoreDiff(x, y, 2, WEIGHT_SMOKING * RATIO_SMOKER_MISMATCH);
+        }
+
+        // 비 & 흡
+        int smoker = h1 ? x : y;
+        return switch (smoker) {
+            case 3 -> WEIGHT_SMOKING * RATIO_VAPE;
+            case 2 -> WEIGHT_SMOKING * RATIO_IQOS;
+            case 1 -> WEIGHT_SMOKING * RATIO_CIGARETTE;
+            default -> 0.0;
+        };
+    }
+
+}

src/main/java/com/cozymate/cozymate_server/domain/memberstat/calculator/penalty/NoiseCalculator.java

@@ -0,0 +1,74 @@
+package com.cozymate.cozymate_server.domain.memberstat.calculator.penalty;
+
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.Lifestyle;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.enums.StatKey;
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.util.QuestionAnswerMapper;
+import org.springframework.stereotype.Component;
+
+@Component
+public class NoiseCalculator implements PenaltyCalculator {
+
+    private static final double WEIGHT_NOISE_SENS = 10.0;
+    private static final double WEIGHT_GAME = 5.0;
+    private static final double WEIGHT_STUDY = 5.0;
+    private static final double WEIGHT_CALL = 5.0;
+    private static final double WEIGHT_SLEEPING_HABIT = 5.0;
+
+    private static final int SLEEPING_NONE_MASK = 1;
+    private static final int SLEEPING_COUNT_CAP = 4;
+
+    private static final int GAP_NOISE_SENS = QuestionAnswerMapper.gapOf(StatKey.NOISE_SENSITIVITY);
+    private static final int GAP_GAME = QuestionAnswerMapper.gapOf(StatKey.GAMING_STATUS);
+    private static final int GAP_STUDY = QuestionAnswerMapper.gapOf(StatKey.STUDYING_STATUS);
+    private static final int GAP_CALL = QuestionAnswerMapper.gapOf(StatKey.CALLING_STATUS);
+
+    @Override
+    public Group getGroup() {
+        return Group.A_NOISE;
+    }
+    @Override
+    public double calculatePenalty(Lifestyle a, Lifestyle b) {
+        double p = 0.0;
+        p += scoreDiff(a.getNoiseSensitivity(), b.getNoiseSensitivity(),
+            GAP_NOISE_SENS, WEIGHT_NOISE_SENS);
+        p += scoreDiff(a.getPlayingGameFrequency(), b.getPlayingGameFrequency(),
+            GAP_GAME, WEIGHT_GAME);
+        p += scoreDiff(a.getStudyingFrequency(), b.getStudyingFrequency(),
+            GAP_STUDY, WEIGHT_STUDY);
+        p += scoreDiff(a.getPhoneCallingFrequency(), b.getPhoneCallingFrequency(),
+            GAP_CALL, WEIGHT_CALL);
+        p += scoreSleepingHabitPenalty(a.getSleepingHabit(), b.getSleepingHabit()
+        );
+        return p;
+    }
+
+    private double scoreSleepingHabitPenalty(int x, int y) {
+        double w = Math.max(1.0, WEIGHT_SLEEPING_HABIT);
+
+        if (isOnlyNone(x) && isOnlyNone(y)) {
+            return 0.0; // 둘 다 없음
+        }
+
+        boolean hasX = !isOnlyNone(x) && countHabitsExcludingNone(x) > 0;
+        boolean hasY = !isOnlyNone(y) && countHabitsExcludingNone(y) > 0;
+
+        if (hasX && hasY) {
+            return 1.0;
+        }
+
+        int n = countHabitsExcludingNone(hasX ? x : y);
+        int capped = Math.min(n, SLEEPING_COUNT_CAP);
+        return 1.0 + (capped / (double) SLEEPING_COUNT_CAP) * (w - 1.0);
+    }
+
+    private boolean isOnlyNone(int mask) {
+        return mask == SLEEPING_NONE_MASK;
+    }
+
+    private int countHabitsExcludingNone(int mask) {
+        return Integer.bitCount(mask & ~SLEEPING_NONE_MASK);
+    }
+
+
+}
+

src/main/java/com/cozymate/cozymate_server/domain/memberstat/calculator/penalty/PenaltyCalculator.java

@@ -0,0 +1,68 @@
+package com.cozymate.cozymate_server.domain.memberstat.calculator.penalty;
+
+import com.cozymate.cozymate_server.domain.memberstat.memberstat.Lifestyle;
+
+public interface PenaltyCalculator {
+    Group getGroup();
+    double calculatePenalty(Lifestyle a, Lifestyle b);
+
+    /**
+     * 값이 다르면 가중치 전부를 감점.
+     *
+     * @param x      첫 번째 값
+     * @param y      두 번째 값
+     * @param weight 감점 가중치(예: 5.0)
+     * @return 동일하면 0.0, 다르면 weight
+     */
+    default double scoreAnyDiff(int x, int y, double weight) {
+        return x == y ? 0.0 : weight;
+    }
+
+    /**
+     * 값의 차이에 비례해 선형으로 감점
+     * - 공식: penalty = min(diff, gap) / gap * weight
+     * - 차이가 0이면 0.0, 차이가 gap 이상이면 weight(풀 감점).
+     * - 예: 척도형(0~4)에서 "4칸 차이면 풀 감점" → gap=4
+     * @param x 첫 번째 값
+     * @param y 두 번째 값
+     * @param gap 풀 감점이 되는 기준 차이(>0)
+     * @param weight 감점 가중치(예: 10.0)
+     * @return 0.0 ~ weight
+     */
+    default double scoreDiff(int x, int y, int gap, double weight) {
+        int diff = Math.abs(x - y);
+        if (diff == 0) {
+            return 0.0;
+        }
+        if (diff >= gap) {
+            return weight;
+        }
+        return (diff / (double) gap) * weight;
+    }
+
+    /**
+     * 시간(0~23)의 차이로 감점한다.
+     * - 원형 거리 d = min((h2 - h1 + 24) % 24, (h1 - h2 + 24) % 24)
+     * - 규칙: d=0 → 0.0, d=1 → weight*0.3, d=2 → weight*0.7, d>=3 → weight
+     * - 예: 취침/기상/소등 시간 비교 등
+     * @param x 첫 번째 시간(0~23)
+     * @param y 두 번째 시간(0~23)
+     * @param weight 감점 가중치(예: 10.0)
+     * @return 0.0 ~ weight
+     */
+    default double scoreHour(int x, int y, double weight) {
+        int d = Math.min((x - y + 24) % 24, (y - x + 24) % 24);
+        if (d == 0) {
+            return 0.0;
+        }
+        if (d == 1) {
+            return weight * 0.3;
+        }
+        if (d == 2) {
+            return weight * 0.7;
+        }
+        return weight;
+    }
+
+}
+