mecab-ko-core 0.7.2

//! 어미 분리 규칙 정의

use super::types::EndingRule;

/// 어미 분리 규칙 초기화
///
/// 품사 패턴별 어미 분리 규칙의 목록을 반환합니다.
#[allow(clippy::too_many_lines, clippy::vec_init_then_push)]
#[must_use]
pub(super) fn init_ending_rules() -> Vec<EndingRule> {
    let mut rules: Vec<EndingRule> = Vec::new();

    // 종결어미 (EF) - 확장
    rules.push(EndingRule::new(
        "VV+EF",
        vec![
            // 격식체 종결어미
            "습니다",
            "ㅂ니다",
            "습니까",
            "ㅂ니까", // 합쇼체
            "는다",
            "ㄴ다",
            "는가",
            "ㄴ가",
            "냐",
            "니", // 해라체
            "오",
            "소", // 하오체
            "네",
            "세",
            "게", // 하게체
            // 비격식체 종결어미
            "어요",
            "아요",
            "요", // 해요체
            "어",
            "아", // 해체
            // 기타 종결어미
            "지",
            "죠",
            "죠", // 추측/확인
            "군",
            "구나",
            "구먼", // 감탄
            "래",
            "려",
            "자", // 청유
            "마",
            "거라",
            "너라", // 명령
            "랴",
            "리", // 의문
            "다", // 기본 종결
            // 미래/의지 종결어미
            "ㄹ게요",
            "ㄹ게",
            "ㄹ래요",
            "ㄹ래",
            "ㄹ까요",
            "ㄹ까",
        ],
        vec!["VV", "EF"],
    ));

    rules.push(EndingRule::new(
        "VA+EF",
        vec![
            // 격식체
            "습니다",
            "ㅂ니다",
            "습니까",
            "ㅂ니까",
            // 비격식체
            "다",
            "어요",
            "아요",
            "요",
            "어",
            "아",
            // 기타
            "지",
            "죠",
            "네",
            "군",
            "구나",
        ],
        vec!["VA", "EF"],
    ));

    // XSV (파생접미사) + 종결어미 (EF)
    rules.push(EndingRule::new(
        "XSV+EF",
        vec![
            // 격식체
            "습니다",
            "ㅂ니다",
            "습니까",
            "ㅂ니까",
            // 비격식체
            "다",
            "어요",
            "아요",
            "요",
            "어",
            "아",
            // 축약형
            "ㄴ다",
            "ㅆ다",
            // 기타
            "지",
            "죠",
            "네",
        ],
        vec!["XSV", "EF"],
    ));

    // XSV + 연결어미 (EC)
    rules.push(EndingRule::new(
        "XSV+EC",
        vec![
            "고",
            "면",
            "으면",
            "서",
            "어서",
            "아서",
            "면서",
            "으면서",
            "니까",
            "으니까",
            "지만",
        ],
        vec!["XSV", "EC"],
    ));

    // VX (보조용언) + 종결어미 (EF)
    rules.push(EndingRule::new(
        "VX+EF",
        vec![
            // 격식체
            "습니다",
            "ㅂ니다",
            "습니까",
            "ㅂ니까",
            // 비격식체
            "어요",
            "아요",
            "요",
            "어",
            "아",
            "다",
            // 축약형
            "ㄴ다",
            "ㅆ다",
            // 기타
            "지",
            "죠",
            "네",
        ],
        vec!["VX", "EF"],
    ));

    // EP+EF (긍정지정사+어미) - "입니다" 패턴 처리
    // "입니다" → "이/VCP + 습니다/EF"
    rules.push(EndingRule::new(
        "EP+EF",
        vec!["입니다", "입니까"],
        vec!["VCP", "EF"],
    ));

    // VV + VX + EF (피동/사동 구문) - 특별 처리
    // 예: 보이다 → 보/VV + 이/VX + 다/EF
    // 예: 만들어지다 → 만들/VV + 어지/VX + 다/EF (181차)
    // 패턴: 어간 + (이/히/리/기/어지/아지) + 다
    rules.push(EndingRule::new(
        "VV+VX+EF",
        vec![
            "어지다",
            "아지다", // 피동 확장 (181차)
            "이다",
            "히다",
            "리다",
            "기다", // 피동/사동 기본형
        ],
        vec!["VV", "VX", "EF"],
    ));

    // VX + 연결어미 (EC)
    rules.push(EndingRule::new(
        "VX+EC",
        vec![
            "고",
            "면",
            "으면",
            "서",
            "어서",
            "아서",
            "면서",
            "으면서",
            "니까",
            "으니까",
            "지만",
        ],
        vec!["VX", "EC"],
    ));

    // 연결어미 (EC) - 확장
    // NOTE: 긴 패턴을 먼저 배치하여 올바른 매칭 (예: "아서" > "서")
    rules.push(EndingRule::new(
        "VV+EC",
        vec![
            // 긴 패턴 우선 (복합 연결어미)
            "고나서",
            "자마자",
            "으면서",
            "으니까",
            "더라도",
            "으므로",
            // 3글자 연결어미
            "어서",
            "아서",
            "면서",
            "든지",
            "든가",
            "기에",
            "길래",
            "거든",
            "다면",
            "어도",
            "아도",
            "도록",
            "듯이",
            "데도",
            // 2글자 연결어미
            "니까",
            "므로",
            "지만",
            "거나",
            "다가",
            "더니",
            "ㄴ데",
            "는데",
            // 1글자 연결어미 (마지막에 배치)
            "고",
            "며",
            "나",
            "니",
            "면",
            "서",
            "자",
            "게",
            "듯",
        ],
        vec!["VV", "EC"],
    ));

    // NOTE: 긴 패턴을 먼저 배치하여 올바른 매칭
    rules.push(EndingRule::new(
        "VA+EC",
        vec![
            // 긴 패턴 우선
            "더라도",
            "으면서",
            "으니까",
            // 3글자 연결어미
            "어서",
            "아서",
            "면서",
            "어도",
            "아도",
            "도록",
            // 2글자 연결어미
            "니까",
            "므로",
            "지만",
            "거나",
            "거든",
            "다면",
            "ㄴ데",
            "는데",
            "더니",
            // 1글자 연결어미 (마지막)
            "고",
            "며",
            "나",
            "니",
            "면",
            "서",
            "게",
        ],
        vec!["VA", "EC"],
    ));

    // 관형형어미 (ETM) - 확장
    rules.push(EndingRule::new(
        "VV+ETM",
        vec![
            "는", // 현재 관형형 (먹는)
            "ㄴ", "은", // 과거 관형형 (먹은)
            "ㄹ", "을", // 미래 관형형 (먹을)
            "던", // 회상 관형형 (먹던)
        ],
        vec!["VV", "ETM"],
    ));

    rules.push(EndingRule::new(
        "VA+ETM",
        vec![
            "ㄴ", "은", // 현재 관형형 (좋은, 큰)
            "ㄹ", "을", // 미래 관형형 (좋을)
            "던", // 회상 관형형 (좋던)
        ],
        vec!["VA", "ETM"],
    ));

    // 명사형어미 (ETN) - 확장
    rules.push(EndingRule::new(
        "VV+ETN",
        vec![
            "기", // 명사형 (먹기)
            "ㅁ", "음", // 명사형 (먹음)
        ],
        vec!["VV", "ETN"],
    ));

    rules.push(EndingRule::new(
        "VA+ETN",
        vec![
            "기", // 명사형 (좋기)
            "ㅁ", "음", // 명사형 (좋음)
        ],
        vec!["VA", "ETN"],
    ));

    // 선어말어미 (EP) 단독 - 시제/양태
    rules.push(EndingRule::new(
        "VV+EP",
        vec![
            "었", "았", "였", // 과거 시제
            "겠", // 추측/의지
            "시", "으시", // 높임
            "더",   // 회상
        ],
        vec!["VV", "EP"],
    ));

    rules.push(EndingRule::new(
        "VA+EP",
        vec![
            "었", "았", "였", // 과거 시제
            "겠", // 추측
            "시", "으시", // 높임
        ],
        vec!["VA", "EP"],
    ));

    // 존칭+과거 복합형 (VV+EP+EP+EF): 오시었습니다 → 오 + 시 + 었 + 습니다
    rules.push(EndingRule::new(
        "VV+EP+EP+EF",
        vec!["셨습니다", "셨습니까", "셨어요", "셨어", "셨다"],
        vec!["VV", "EP", "EP", "EF"],
    ));

    // 선어말어미 + 종결어미 (EP+EF) - 확장
    // NOTE: 긴 패턴을 먼저 배치하여 올바른 매칭
    rules.push(EndingRule::new(
        "VV+EP+EF",
        vec![
            // 긴 패턴 우선 (5글자 이상)
            "으셨습니다",
            "으셨습니까",
            "으셨어요",
            // 4글자 패턴
            "었습니다",
            "았습니다",
            "였습니다",
            "었습니까",
            "았습니까",
            "였습니까",
            "겠습니다",
            "셨습니다",
            // 3글자 패턴
            "었어요",
            "았어요",
            "였어요",
            "었어",
            "았어",
            "였어",
            "었다",
            "았다",
            "였다",
            "었니",
            "았니",
            "였니",
            "었지",
            "았지",
            "였지",
            "었나",
            "았나",
            "였나",
            "겠어요",
            "겠다",
            "겠지",
            "겠어",
            "셨어요",
            "셨다",
            "셨어",
            "시네요",
            "으시네요",
            // 2글자 패턴
            "더라",
            "더군",
            "더니",
            "던데",
        ],
        vec!["VV", "EP", "EF"],
    ));

    rules.push(EndingRule::new(
        "VA+EP+EF",
        vec![
            // 과거 + 격식체
            "었습니다",
            "았습니다",
            "였습니다",
            "었습니까",
            "았습니까",
            "였습니까",
            // 과거 + 비격식체
            "었어요",
            "았어요",
            "였어요",
            "었어",
            "았어",
            "였어",
            "었다",
            "았다",
            "였다",
            "었지",
            "았지",
            "였지",
            // 추측
            "겠습니다",
            "겠어요",
            "겠다",
            "겠지",
            // 높임
            "시네요",
            "으시네요",
            "셨어요",
            "셨다",
        ],
        vec!["VA", "EP", "EF"],
    ));

    // 선어말어미 + 연결어미 (EP+EC)
    rules.push(EndingRule::new(
        "VV+EP+EC",
        vec![
            // 과거 + 연결
            "었고",
            "았고",
            "였고",
            "었는데",
            "았는데",
            "였는데",
            "었지만",
            "았지만",
            "였지만",
            "었으면",
            "았으면",
            "였으면",
            "었어도",
            "았어도",
            "였어도",
            "었으니",
            "았으니",
            "였으니",
            // 추측 + 연결
            "겠고",
            "겠는데",
            "겠지만",
        ],
        vec!["VV", "EP", "EC"],
    ));

    rules.push(EndingRule::new(
        "VA+EP+EC",
        vec![
            "었고",
            "았고",
            "였고",
            "었는데",
            "았는데",
            "였는데",
            "었지만",
            "았지만",
            "였지만",
            "었으면",
            "았으면",
            "였으면",
        ],
        vec!["VA", "EP", "EC"],
    ));

    // 선어말어미 + 관형형어미 (EP+ETM)
    rules.push(EndingRule::new(
        "VV+EP+ETM",
        vec![
            "었던", "았던", "였던", // 과거 회상 관형형
            "겠을", // 추측 미래 관형형
        ],
        vec!["VV", "EP", "ETM"],
    ));

    // ========== 조사 분리 규칙 ==========

    // 주격조사 (JKS)
    rules.push(EndingRule::new(
        "NNG+JKS",
        vec!["이", "가", "께서"],
        vec!["NNG", "JKS"],
    ));
    rules.push(EndingRule::new(
        "NNP+JKS",
        vec!["이", "가", "께서"],
        vec!["NNP", "JKS"],
    ));
    rules.push(EndingRule::new(
        "NP+JKS",
        vec!["이", "가", "께서"],
        vec!["NP", "JKS"],
    ));

    // 목적격조사 (JKO)
    rules.push(EndingRule::new(
        "NNG+JKO",
        vec!["을", "를"],
        vec!["NNG", "JKO"],
    ));
    rules.push(EndingRule::new(
        "NNP+JKO",
        vec!["을", "를"],
        vec!["NNP", "JKO"],
    ));
    rules.push(EndingRule::new(
        "NP+JKO",
        vec!["을", "를"],
        vec!["NP", "JKO"],
    ));

    // 부사격조사 (JKB)
    rules.push(EndingRule::new(
        "NNG+JKB",
        vec![
            "에", "에서", "에게", "로", "으로", "한테", "보다", "처럼", "같이", "까지", "부터",
            "와", "과",
        ],
        vec!["NNG", "JKB"],
    ));
    rules.push(EndingRule::new(
        "NNP+JKB",
        vec![
            "에", "에서", "에게", "로", "으로", "한테", "보다", "처럼", "같이", "까지", "부터",
            "와", "과",
        ],
        vec!["NNP", "JKB"],
    ));
    rules.push(EndingRule::new(
        "NP+JKB",
        vec![
            "에", "에서", "에게", "로", "으로", "한테", "보다", "처럼", "같이", "까지", "부터",
            "와", "과",
        ],
        vec!["NP", "JKB"],
    ));

    // 관형격조사 (JKG)
    rules.push(EndingRule::new("NNG+JKG", vec!["의"], vec!["NNG", "JKG"]));
    rules.push(EndingRule::new("NNP+JKG", vec!["의"], vec!["NNP", "JKG"]));

    // 호격조사 (JKV)
    rules.push(EndingRule::new(
        "NNG+JKV",
        vec!["아", "야", "여", "이여"],
        vec!["NNG", "JKV"],
    ));
    rules.push(EndingRule::new(
        "NNP+JKV",
        vec!["아", "야", "여", "이여"],
        vec!["NNP", "JKV"],
    ));

    // 보조사 (JX)
    rules.push(EndingRule::new(
        "NNG+JX",
        vec![
            "은", "는", "도", "만", "까지", "부터", "마저", "조차", "라도", "밖에", "요",
        ],
        vec!["NNG", "JX"],
    ));
    rules.push(EndingRule::new(
        "NNP+JX",
        vec![
            "은", "는", "도", "만", "까지", "부터", "마저", "조차", "라도", "밖에", "요",
        ],
        vec!["NNP", "JX"],
    ));
    rules.push(EndingRule::new(
        "NP+JX",
        vec![
            "은", "는", "도", "만", "까지", "부터", "마저", "조차", "라도", "밖에", "요",
        ],
        vec!["NP", "JX"],
    ));

    // 접속조사 (JC)
    rules.push(EndingRule::new(
        "NNG+JC",
        vec!["와", "과", "이랑", "랑", "하고"],
        vec!["NNG", "JC"],
    ));

    rules
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_init_ending_rules_returns_nonempty_list() {
        let rules = init_ending_rules();
        assert!(!rules.is_empty(), "ending rules must not be empty");
    }

    #[test]
    fn test_init_ending_rules_vv_ef_contains_key_endings() {
        let rules = init_ending_rules();
        let vv_ef = rules
            .iter()
            .find(|r| r.pos_pattern == "VV+EF")
            .expect("VV+EF rule must exist");
        assert_eq!(vv_ef.target_tags, vec!["VV".to_string(), "EF".to_string()]);
        assert!(
            vv_ef.endings.contains(&"어요".to_string()),
            "VV+EF must include 어요"
        );
        assert!(
            vv_ef.endings.contains(&"다".to_string()),
            "VV+EF must include 다"
        );
    }

    #[test]
    fn test_init_ending_rules_noun_particle_rules_present() {
        let rules = init_ending_rules();
        // 명사+주격조사 규칙 존재
        let jks_rule = rules.iter().find(|r| r.pos_pattern == "NNG+JKS");
        assert!(jks_rule.is_some(), "NNG+JKS rule must exist");
        // 명사+목적격조사 규칙: 을/를 포함
        let jko_rule = rules
            .iter()
            .find(|r| r.pos_pattern == "NNG+JKO")
            .expect("NNG+JKO rule must exist");
        assert!(jko_rule.endings.contains(&"을".to_string()));
        assert!(jko_rule.endings.contains(&"를".to_string()));
    }
}