// morphology-sw.el - Swahili morphology for the NLG engine.
//
// Implements Swahili noun class detection, subject/object agreement prefixes,
// tense markers, verb conjugation, negation, noun pluralization, and adjective
// agreement.
//
// Swahili is an agglutinative SVO language that uses a noun class system
// (15+ classes) instead of grammatical gender.  Noun classes determine the
// agreement prefixes on verbs, adjectives, and other nominals.
//
// Key facts:
//   - No case endings — word order and prepositions handle relations
//   - Verb morphology: SUBJ-TENSE-OBJ-STEM(-final vowel)
//   - Latin script; tonal but tone unmarked in standard orthography
//
// Conventions used throughout:
//   class:   "1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"|"10"|"11"|"15"
//   person:  "1sg"|"2sg"|"3sg"|"1pl"|"2pl"|"3pl" | "1"|"2"|"3" + number "sg"/"pl"
//   tense:   "present"|"progressive"|"past"|"future"|"perfect"
//   number:  "sg" | "pl"
//
// Depends on: morphology.el (str_eq, str_len, str_slice, str_ends_with,
//             str_drop_last)

// ── String helpers ────────────────────────────────────────────────────────────

fn sw_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
}

fn sw_str_drop_last(s: String, n: Int) -> String {
    let len: Int = str_len(s)
    if n >= len {
        return ""
    }
    return str_slice(s, 0, len - n)
}

fn sw_str_first_char(s: String) -> String {
    let n: Int = str_len(s)
    if n == 0 {
        return ""
    }
    return str_slice(s, 0, 1)
}

fn sw_str_first2(s: String) -> String {
    let n: Int = str_len(s)
    if n < 2 {
        return s
    }
    return str_slice(s, 0, 2)
}

fn sw_str_first3(s: String) -> String {
    let n: Int = str_len(s)
    if n < 3 {
        return s
    }
    return str_slice(s, 0, 3)
}

fn sw_str_last_char(s: String) -> String {
    let n: Int = str_len(s)
    if n == 0 {
        return ""
    }
    return str_slice(s, n - 1, n)
}

// ── Noun class detection ──────────────────────────────────────────────────────
//
// Returns the singular noun class number as a string.
// The noun class is inferred from the noun's prefix according to the standard
// Bantu noun class system used in Swahili.
//
// Class pairs (singular/plural):
//   Class 1/2  (M-WA):  m-/mw-  → wa-    people, animates
//   Class 3/4  (M-MI):  m-/mw-  → mi-    trees, plants, objects
//   Class 5/6  (JI-MA): ji-/j-  → ma-    fruits, augmentatives
//   Class 7/8  (KI-VI): ki-/ch- → vi-/vy- things, languages
//   Class 9/10 (N):     n-/m-/∅ → same   animals, loanwords
//   Class 11   (U):     u-/w-   → (10)   abstract nouns
//   Class 15   (KU):    ku-     → —      infinitives as nouns
//
// Disambiguation between class 1 and class 3 (both m-/mw- prefix):
//   Class 1 nouns refer to people/animates; class 3 to inanimate objects/plants.
//   A lexical lookup for common class 1 nouns handles the ambiguous cases.
//
// Note: Class 9/10 nouns often have no visible prefix (zero-prefix or nasal
// prefix that assimilates to the following consonant).

fn sw_is_class1_noun(noun: String) -> Bool {
    // Known class 1 (M-WA: human/animate) nouns
    if str_eq(noun, "mtu")      { return true }   // person
    if str_eq(noun, "mwanafunzi") { return true } // student
    if str_eq(noun, "mwalimu")  { return true }   // teacher
    if str_eq(noun, "mke")      { return true }   // wife/woman
    if str_eq(noun, "mume")     { return true }   // husband/man
    if str_eq(noun, "mtoto")    { return true }   // child
    if str_eq(noun, "mgeni")    { return true }   // guest/stranger
    if str_eq(noun, "mwana")    { return true }   // child/son
    if str_eq(noun, "mkubwa")   { return true }   // elder/adult
    if str_eq(noun, "mdogo")    { return true }   // young one
    if str_eq(noun, "mgonjwa")  { return true }   // sick person/patient
    if str_eq(noun, "mfanyakazi") { return true } // worker
    if str_eq(noun, "mkulima")  { return true }   // farmer
    if str_eq(noun, "mwimbaji") { return true }   // singer
    if str_eq(noun, "msomaji")  { return true }   // reader
    if str_eq(noun, "mwandishi") { return true }  // writer
    if str_eq(noun, "mpiganaji") { return true }  // fighter/warrior
    if str_eq(noun, "msaidizi") { return true }   // helper
    if str_eq(noun, "mpishi")   { return true }   // cook
    if str_eq(noun, "mwanasheria") { return true } // lawyer
    if str_eq(noun, "daktari")  { return true }   // doctor (cl.9, but animate)
    if str_eq(noun, "rafiki")   { return true }   // friend (cl.9)
    if str_eq(noun, "ndugu")    { return true }   // sibling/relative (cl.9)
    return false
}

fn sw_noun_class(noun: String) -> String {
    // Class 15: ku- prefix — infinitives used as nouns
    if sw_str_ends(noun, "ku") {
        if str_eq(sw_str_first2(noun), "ku") { return "15" }
    }
    if sw_str_first2(noun) == "ku" { return "15" }

    // Explicit class 15 check
    let p2: String = sw_str_first2(noun)
    if str_eq(p2, "ku") { return "15" }

    // Class 7/8 (KI-VI): ki- or ch-
    let p3: String = sw_str_first3(noun)
    if str_eq(p3, "ki-") { return "7" }
    if str_eq(p2, "ki")  { return "7" }
    if str_eq(p2, "ch")  { return "7" }   // e.g. chakula (food), choo (toilet)

    // Class 11 (U): u- or w- prefix — abstract nouns
    // Must check before class 1/3 m- prefix checks
    let p1: String = sw_str_first_char(noun)
    if str_eq(p1, "u") { return "11" }
    if str_eq(p1, "w") { return "11" }    // e.g. wimbo (song) class 11

    // Class 5/6 (JI-MA): ji- prefix or zero-prefix fruits/augmentatives
    if str_eq(p2, "ji") { return "5" }
    // Common class 5 nouns with zero prefix (j- before vowel)
    if str_eq(noun, "jicho")  { return "5" }  // eye
    if str_eq(noun, "jino")   { return "5" }  // tooth
    if str_eq(noun, "bega")   { return "5" }  // shoulder
    if str_eq(noun, "tunda")  { return "5" }  // fruit
    if str_eq(noun, "embe")   { return "5" }  // mango
    if str_eq(noun, "gari")   { return "5" }  // car/vehicle
    if str_eq(noun, "bei")    { return "5" }  // price
    if str_eq(noun, "sauti")  { return "5" }  // voice/sound
    if str_eq(noun, "thamani") { return "5" } // value

    // Class 1/3 (M- prefix): disambiguate by lexical lookup
    if str_eq(p1, "m") {
        if sw_is_class1_noun(noun) { return "1" }
        return "3"   // class 3: trees, plants, inanimate m- nouns
    }
    if str_eq(p2, "mw") {
        if sw_is_class1_noun(noun) { return "1" }
        return "3"
    }

    // Class 9/10 (N): nasal prefix or zero prefix — catch-all for most
    // loanwords and animal names
    // Many class 9 nouns start with: n, ny, ng, mb, nd, nj, nz, or bare vowel
    if str_eq(p2, "ny") { return "9" }
    if str_eq(p2, "ng") { return "9" }
    if str_eq(p2, "mb") { return "9" }
    if str_eq(p2, "nd") { return "9" }
    if str_eq(p2, "nj") { return "9" }
    if str_eq(p2, "nz") { return "9" }
    if str_eq(p1, "n")  { return "9" }

    // Common lexical class 9 nouns (animals, loanwords, etc.)
    if str_eq(noun, "paka")    { return "9" }   // cat
    if str_eq(noun, "mbwa")    { return "9" }   // dog
    if str_eq(noun, "simba")   { return "9" }   // lion
    if str_eq(noun, "tembo")   { return "9" }   // elephant
    if str_eq(noun, "nyoka")   { return "9" }   // snake
    if str_eq(noun, "samaki")  { return "9" }   // fish
    if str_eq(noun, "rafiki")  { return "9" }   // friend
    if str_eq(noun, "daktari") { return "9" }   // doctor
    if str_eq(noun, "serikali") { return "9" }  // government
    if str_eq(noun, "hospitali") { return "9" } // hospital
    if str_eq(noun, "shule")   { return "9" }   // school
    if str_eq(noun, "kanisa")  { return "9" }   // church
    if str_eq(noun, "ofisi")   { return "9" }   // office
    if str_eq(noun, "picha")   { return "9" }   // picture/photo
    if str_eq(noun, "sehemu")  { return "9" }   // part/section
    if str_eq(noun, "habari")  { return "9" }   // news
    if str_eq(noun, "nchi")    { return "9" }   // country/land
    if str_eq(noun, "bahari")  { return "9" }   // sea/ocean
    if str_eq(noun, "dunia")   { return "9" }   // world
    if str_eq(noun, "ardhi")   { return "9" }   // ground/earth

    // Default to class 9 for unknown nouns (most common catch-all)
    return "9"
}

// ── Subject agreement prefixes ────────────────────────────────────────────────
//
// Returns the subject prefix for verb conjugation.
//
// For personal pronouns: person "1","2","3" + number "sg","pl"
// For noun class agreement: person "3" + the noun's class
//
// Personal:
//   1sg (mimi)  → ni-
//   2sg (wewe)  → u-
//   3sg class 1 → a-
//   1pl (sisi)  → tu-
//   2pl (nyinyi)→ m-
//   3pl class 2 → wa-
//
// Noun class 3sg:
//   cl.1  → a-     cl.2  → wa-
//   cl.3  → u-     cl.4  → i-
//   cl.5  → li-    cl.6  → ya-
//   cl.7  → ki-    cl.8  → vi-
//   cl.9  → i-     cl.10 → zi-
//   cl.11 → u-     cl.15 → ku-

fn sw_subj_prefix(person: String, number: String, noun_class: String) -> String {
    // First and second person always use personal prefixes regardless of noun class
    if str_eq(person, "1") {
        if str_eq(number, "sg") { return "ni" }
        return "tu"
    }
    if str_eq(person, "2") {
        if str_eq(number, "sg") { return "u" }
        return "m"
    }

    // Third person: agree with noun class
    // Plural classes
    if str_eq(number, "pl") {
        if str_eq(noun_class, "1") { return "wa" }   // class 2 (wa-)
        if str_eq(noun_class, "2") { return "wa" }
        if str_eq(noun_class, "3") { return "i" }    // class 4 (i-)
        if str_eq(noun_class, "4") { return "i" }
        if str_eq(noun_class, "5") { return "ya" }   // class 6 (ya-)
        if str_eq(noun_class, "6") { return "ya" }
        if str_eq(noun_class, "7") { return "vi" }   // class 8 (vi-)
        if str_eq(noun_class, "8") { return "vi" }
        if str_eq(noun_class, "9") { return "zi" }   // class 10 (zi-)
        if str_eq(noun_class, "10") { return "zi" }
        if str_eq(noun_class, "11") { return "zi" }  // class 11 pl uses cl.10
        return "zi"
    }

    // Singular classes
    if str_eq(noun_class, "1")  { return "a" }
    if str_eq(noun_class, "3")  { return "u" }
    if str_eq(noun_class, "4")  { return "i" }
    if str_eq(noun_class, "5")  { return "li" }
    if str_eq(noun_class, "6")  { return "ya" }
    if str_eq(noun_class, "7")  { return "ki" }
    if str_eq(noun_class, "8")  { return "vi" }
    if str_eq(noun_class, "9")  { return "i" }
    if str_eq(noun_class, "10") { return "zi" }
    if str_eq(noun_class, "11") { return "u" }
    if str_eq(noun_class, "15") { return "ku" }
    // Default: third person animate sg
    return "a"
}

// ── Object agreement prefixes ─────────────────────────────────────────────────
//
// Object infixes are inserted between tense marker and verb stem.
// They mirror the subject prefixes with minor differences.
//
//   1sg → ni-    2sg → ku-    3sg cl.1 → m-/mw-
//   1pl → tu-    2pl → wa-    3pl cl.2 → wa-
//   cl.3 sg → u-    cl.4 pl → i-
//   cl.5 sg → li-   cl.6 pl → ya-
//   cl.7 sg → ki-   cl.8 pl → vi-
//   cl.9 sg → i-    cl.10 pl → zi-
//   cl.11 → u-      cl.15 → ku-

fn sw_obj_prefix(person: String, number: String, noun_class: String) -> String {
    if str_eq(person, "1") {
        if str_eq(number, "sg") { return "ni" }
        return "tu"
    }
    if str_eq(person, "2") {
        if str_eq(number, "sg") { return "ku" }
        return "wa"
    }
    // Third person object
    if str_eq(number, "pl") {
        if str_eq(noun_class, "1") { return "wa" }
        if str_eq(noun_class, "2") { return "wa" }
        if str_eq(noun_class, "3") { return "i" }
        if str_eq(noun_class, "4") { return "i" }
        if str_eq(noun_class, "5") { return "ya" }
        if str_eq(noun_class, "6") { return "ya" }
        if str_eq(noun_class, "7") { return "vi" }
        if str_eq(noun_class, "8") { return "vi" }
        if str_eq(noun_class, "9") { return "zi" }
        if str_eq(noun_class, "10") { return "zi" }
        return "wa"
    }
    // Singular
    if str_eq(noun_class, "1")  { return "m" }
    if str_eq(noun_class, "3")  { return "u" }
    if str_eq(noun_class, "5")  { return "li" }
    if str_eq(noun_class, "7")  { return "ki" }
    if str_eq(noun_class, "9")  { return "i" }
    if str_eq(noun_class, "11") { return "u" }
    if str_eq(noun_class, "15") { return "ku" }
    return "m"
}

// ── Tense markers ─────────────────────────────────────────────────────────────
//
// Tense markers are inserted between the subject prefix and the verb stem.
//
//   "present"     → -a-  (habitual/simple present; final vowel -a)
//   "progressive" → -na- (present progressive)
//   "past"        → -li- (simple past)
//   "future"      → -ta- (future)
//   "perfect"     → -me- (present perfect)
//   "remote_past" → -li- (same marker; distinction via context or -ku-)
//   "subjunctive" → (no tense marker; final vowel changes to -e)

fn sw_tense_marker(tense: String) -> String {
    if str_eq(tense, "present")     { return "a" }
    if str_eq(tense, "progressive") { return "na" }
    if str_eq(tense, "past")        { return "li" }
    if str_eq(tense, "future")      { return "ta" }
    if str_eq(tense, "perfect")     { return "me" }
    if str_eq(tense, "subjunctive") { return "" }
    if str_eq(tense, "remote_past") { return "li" }
    // Default to progressive marker
    return "na"
}

// ── Final vowel (verb ending) ─────────────────────────────────────────────────
//
// The final vowel of the verb stem changes based on tense and negation.
//
// Positive forms:
//   present habitual / progressive / past / future / perfect: -a
//   subjunctive:  -e
//
// Negative forms:
//   present:  -i  (the negative present uses -i instead of -a)
//   past:     -a  (negative past: ha- prefix + -ku- tense + stem + -a)
//   others:   -e  (negative subjunctive)
//
// Note: For most tenses the final vowel is simply -a.  Only the negative present
// and subjunctive change it.

fn sw_verb_final(tense: String, negative: Bool) -> String {
    if negative {
        if str_eq(tense, "present")     { return "i" }
        if str_eq(tense, "progressive") { return "i" }
        if str_eq(tense, "subjunctive") { return "e" }
        return "a"
    }
    if str_eq(tense, "subjunctive") { return "e" }
    return "a"
}

// ── Negative subject prefix ───────────────────────────────────────────────────
//
// Negation in Swahili is expressed by replacing the subject prefix with a
// negative counterpart (ha- for most; si- for 1sg).
//
// Positive → Negative subject prefixes:
//   ni-  → si-    (1sg)
//   u-   → hu-    (2sg)
//   a-   → ha-    (3sg cl.1)
//   tu-  → hatu-  (1pl)
//   m-   → ham-   (2pl)
//   wa-  → hawa-  (3pl cl.2)
//   other class 3sg prefixes: ha + prefix (e.g. ha+u = hau, ha+li = hali)

fn sw_neg_subj_prefix(person: String, number: String, noun_class: String) -> String {
    if str_eq(person, "1") {
        if str_eq(number, "sg") { return "si" }
        return "hatu"
    }
    if str_eq(person, "2") {
        if str_eq(number, "sg") { return "hu" }
        return "ham"
    }
    // Third person negative = ha + positive subject prefix
    let pos: String = sw_subj_prefix(person, number, noun_class)
    return "ha" + pos
}

// ── Stem extraction ───────────────────────────────────────────────────────────
//
// Swahili infinitives begin with ku-.  The verb stem is the infinitive minus ku-.
// For verbs where the stem itself starts with a vowel, the ku- is retained in
// some contexts (kuomba, kusoma etc.) but stripped for conjugation.
//
// Special cases:
//   kula  (to eat)  → stem: l-  (kula → la in conjugation: anakula)
//   kuwa  (to be)   → stem: wa  (but equatorial forms are suppletive: ni/u/ni)
//   kwenda (to go)  → stem: end (kw + end → enda)
//   kuja  (to come) → stem: ja

fn sw_verb_stem(infinitive: String) -> String {
    if str_eq(infinitive, "kula")    { return "l" }   // eat — irregular: anakula
    if str_eq(infinitive, "kuwa")    { return "wa" }  // be
    if str_eq(infinitive, "kwenda")  { return "enda" }
    if str_eq(infinitive, "kuja")    { return "ja" }
    if str_eq(infinitive, "kusoma")  { return "soma" }
    if str_eq(infinitive, "kusema")  { return "sema" }
    if str_eq(infinitive, "kuona")   { return "ona" }
    if str_eq(infinitive, "kufanya") { return "fanya" }
    if str_eq(infinitive, "kutaka")  { return "taka" }
    if str_eq(infinitive, "kujua")   { return "jua" }
    if str_eq(infinitive, "kupata")  { return "pata" }
    if str_eq(infinitive, "kuambia") { return "ambia" }
    if str_eq(infinitive, "kuleta")  { return "leta" }
    if str_eq(infinitive, "kuweka")  { return "weka" }
    if str_eq(infinitive, "kuingia") { return "ingia" }
    if str_eq(infinitive, "kutoka")  { return "toka" }
    if str_eq(infinitive, "kupiga")  { return "piga" }
    if str_eq(infinitive, "kuimba")  { return "imba" }
    if str_eq(infinitive, "kucheza") { return "cheza" }
    if str_eq(infinitive, "kulala")  { return "lala" }
    if str_eq(infinitive, "kuandika") { return "andika" }
    if str_eq(infinitive, "kununua") { return "nunua" }
    if str_eq(infinitive, "kuuza")   { return "uza" }
    if str_eq(infinitive, "kupenda") { return "penda" }
    if str_eq(infinitive, "kuchukua") { return "chukua" }
    if str_eq(infinitive, "kulipa")  { return "lipa" }
    if str_eq(infinitive, "kusikia") { return "sikia" }
    if str_eq(infinitive, "kuamka")  { return "amka" }
    if str_eq(infinitive, "kukaa")   { return "kaa" }
    if str_eq(infinitive, "kurudi")  { return "rudi" }
    if str_eq(infinitive, "kushinda") { return "shinda" }
    if str_eq(infinitive, "kusaidia") { return "saidia" }
    if str_eq(infinitive, "kuzungumza") { return "zungumza" }
    if str_eq(infinitive, "kupumzika") { return "pumzika" }
    if str_eq(infinitive, "kufika")  { return "fika" }
    if str_eq(infinitive, "kuomba")  { return "omba" }
    if str_eq(infinitive, "kushukuru") { return "shukuru" }
    // Generic: strip leading ku (2 chars) or kw (for kwenda etc.)
    if sw_str_first2(infinitive) == "ku" {
        return str_slice(infinitive, 2, str_len(infinitive))
    }
    if sw_str_first2(infinitive) == "kw" {
        return str_slice(infinitive, 2, str_len(infinitive))
    }
    return infinitive
}

// ── Positive verb conjugation ─────────────────────────────────────────────────
//
// Structure: SUBJ_PREFIX + TENSE_MARKER + STEM + FINAL_VOWEL
//
// Examples:
//   anasoma    = a (3sg cl.1) + na (prog) + soma (read) + [stem ends -a]
//   nilikula   = ni (1sg) + li (past) + ku (special) + la (kula stem)
//   tutasema   = tu (1pl) + ta (future) + sema (say) + [stem ends -a]
//   amesoma    = a (3sg) + me (perfect) + soma + [final -a]
//
// Special case: kula — the stem is bare "l", and the full conjugation inserts
// ku before the stem in most tenses: a-na-ku-la, a-li-ku-la, a-ta-ku-la
// but a-me-l-a is not standard — standard is amekula.

fn sw_conjugate(verb_stem: String, person: String, number: String, noun_class: String, tense: String) -> String {
    let subj: String = sw_subj_prefix(person, number, noun_class)
    let tm: String = sw_tense_marker(tense)
    let fv: String = sw_verb_final(tense, false)

    // kula (eat) — stem is "l" but conjugates as "kula" after prefix+tense
    if str_eq(verb_stem, "l") {
        if str_eq(tm, "") {
            return subj + "kula"
        }
        return subj + tm + "kula"
    }

    // kuwa (be) — present equational forms are suppletive
    if str_eq(verb_stem, "wa") {
        if str_eq(tense, "present") {
            // Equational: ni/u/ni for 1sg/2sg/3sg; tu/m/ni for pl
            if str_eq(person, "1") {
                if str_eq(number, "sg") { return "ni" }
                return "tu ni"
            }
            if str_eq(person, "2") {
                if str_eq(number, "sg") { return "u" }
                return "m ni"
            }
            // 3sg/3pl: use class-based copula
            if str_eq(number, "sg") {
                // Locative/existential forms: niko, uko, yuko etc. (class-based)
                if str_eq(noun_class, "1")  { return "yuko" }
                if str_eq(noun_class, "3")  { return "upo" }
                if str_eq(noun_class, "5")  { return "lipo" }
                if str_eq(noun_class, "7")  { return "kipo" }
                if str_eq(noun_class, "9")  { return "ipo" }
                if str_eq(noun_class, "11") { return "upo" }
                return "yuko"
            }
            // plural
            if str_eq(noun_class, "1")  { return "wako" }
            if str_eq(noun_class, "3")  { return "ipo" }
            if str_eq(noun_class, "5")  { return "yapo" }
            if str_eq(noun_class, "7")  { return "vipo" }
            if str_eq(noun_class, "9")  { return "zipo" }
            return "wako"
        }
        // Progressive kuwa: niko/uko/yuko (existence/location)
        if str_eq(tense, "progressive") {
            if str_eq(person, "1") {
                if str_eq(number, "sg") { return "niko" }
                return "tuko"
            }
            if str_eq(person, "2") {
                if str_eq(number, "sg") { return "uko" }
                return "mko"
            }
            if str_eq(number, "sg") {
                if str_eq(noun_class, "1") { return "yuko" }
                return subj + "ko"
            }
            if str_eq(noun_class, "1") { return "wako" }
            return subj + "ko"
        }
        // Past/future/perfect kuwa: regular
    }

    // Regular conjugation
    let stem_final: String = sw_str_last_char(verb_stem)

    // If stem already ends in the correct final vowel, don't double it
    if str_eq(fv, "a") {
        if str_eq(stem_final, "a") {
            // Stem ends in -a: result is subj+tm+stem (final -a already present)
            if str_eq(tm, "") {
                return subj + verb_stem
            }
            return subj + tm + verb_stem
        }
    }

    if str_eq(tm, "") {
        return subj + verb_stem + fv
    }
    return subj + tm + verb_stem + fv
}

// ── Negative verb conjugation ─────────────────────────────────────────────────
//
// Negative structure: NEG_SUBJ_PREFIX + (tense) + STEM + FINAL_VOWEL_I
//
// Negative present:
//   ha- prefix replaces subject prefix; final vowel -i
//   e.g. hasomi (he/she doesn't read), sisomi (I don't read)
//
// Negative past:
//   ha- prefix + -ku- tense infix + stem + -a
//   e.g. hakusoma (he/she didn't read), sikusoma (I didn't read)
//
// Negative future:
//   ha- prefix + -ta- + stem + -i (or sometimes -a; -i is more standard)
//   e.g. hatasoma (he/she won't read)
//
// Negative perfect:
//   ha- prefix + -ja- (not yet) + stem + -a
//   e.g. hajaenda (he/she hasn't gone yet)

fn sw_negative(verb_stem: String, person: String, number: String, noun_class: String, tense: String) -> String {
    let neg_subj: String = sw_neg_subj_prefix(person, number, noun_class)

    // kula special gram_case
    if str_eq(verb_stem, "l") {
        if str_eq(tense, "past")   { return neg_subj + "kukula" }
        if str_eq(tense, "perfect") { return neg_subj + "jakula" }
        return neg_subj + "kuli"
    }

    if str_eq(tense, "present") {
        let fv: String = sw_verb_final("present", true)  // -i
        let stem_no_a: String = verb_stem
        // If stem ends in -a, drop it before adding -i (some grammars)
        // Standard: ha + stem-minus-final-a + i
        let slen: Int = str_len(verb_stem)
        if slen > 0 {
            let last: String = sw_str_last_char(verb_stem)
            if str_eq(last, "a") {
                return neg_subj + sw_str_drop_last(verb_stem, 1) + fv
            }
        }
        return neg_subj + verb_stem + fv
    }

    if str_eq(tense, "past") {
        // Negative past: ha + ku + stem + a
        return neg_subj + "ku" + verb_stem + "a"
    }

    if str_eq(tense, "future") {
        // Negative future: ha + ta + stem + i (standard)
        let fv: String = sw_verb_final("present", true)  // -i
        return neg_subj + "ta" + verb_stem + fv
    }

    if str_eq(tense, "perfect") {
        // Negative perfect "not yet": ha + ja + stem + a
        return neg_subj + "ja" + verb_stem + "a"
    }

    if str_eq(tense, "progressive") {
        // Negative progressive: same as negative present
        let fv: String = sw_verb_final("present", true)
        let slen: Int = str_len(verb_stem)
        if slen > 0 {
            let last: String = sw_str_last_char(verb_stem)
            if str_eq(last, "a") {
                return neg_subj + sw_str_drop_last(verb_stem, 1) + fv
            }
        }
        return neg_subj + verb_stem + fv
    }

    // Default negative: ha + stem + i
    return neg_subj + verb_stem + "i"
}

// ── Noun plural formation ─────────────────────────────────────────────────────
//
// Swahili plurals are formed by changing the noun class prefix.
//
// Class 1 (m-/mw-) → Class 2 (wa-):  mtu → watu, mwalimu → walimu
// Class 3 (m-/mw-) → Class 4 (mi-):  mti → miti, mwamba → miamba
// Class 5 (ji-/∅)  → Class 6 (ma-):  jicho → macho, tunda → matunda
// Class 7 (ki-/ch-)→ Class 8 (vi-/vy-): kitu → vitu, chakula → vyakula
// Class 9 (n-/∅)   → Class 10 (n-/∅): same prefix — no change in prefix;
//                    some class 9 nouns add ma- (ma- class) in plural
// Class 11 (u-)    → Class 10 (n-/∅): ubao → mbao
//
// Known lexical exceptions are handled first.

fn sw_noun_plural(noun: String) -> String {
    // ── Lexical irregulars ──────────────────────────────────────────────────
    if str_eq(noun, "mtu")      { return "watu" }
    if str_eq(noun, "mtoto")    { return "watoto" }
    if str_eq(noun, "mke")      { return "wake" }
    if str_eq(noun, "mume")     { return "waume" }
    if str_eq(noun, "mwana")    { return "wana" }
    if str_eq(noun, "mwalimu")  { return "walimu" }
    if str_eq(noun, "mgeni")    { return "wageni" }
    if str_eq(noun, "mwanafunzi") { return "wanafunzi" }
    if str_eq(noun, "mfanyakazi") { return "wafanyakazi" }
    if str_eq(noun, "mkulima")  { return "wakulima" }
    if str_eq(noun, "mgonjwa")  { return "wagonjwa" }
    if str_eq(noun, "jicho")    { return "macho" }
    if str_eq(noun, "jino")     { return "meno" }
    if str_eq(noun, "bega")     { return "mabega" }
    if str_eq(noun, "tunda")    { return "matunda" }
    if str_eq(noun, "gari")     { return "magari" }
    if str_eq(noun, "embe")     { return "maembe" }
    if str_eq(noun, "wimbo")    { return "nyimbo" }   // class 11 → 10
    if str_eq(noun, "ubao")     { return "mbao" }
    if str_eq(noun, "ugonjwa")  { return "magonjwa" }
    if str_eq(noun, "uso")      { return "nyuso" }
    if str_eq(noun, "ukuta")    { return "kuta" }
    if str_eq(noun, "ulimi")    { return "ndimi" }
    if str_eq(noun, "upande")   { return "pande" }
    if str_eq(noun, "uwezo")    { return "nguvu" }  // approximate
    // Class 9/10 nouns: same form sg/pl (zero-change class)
    if str_eq(noun, "paka")    { return "paka" }
    if str_eq(noun, "samaki")  { return "samaki" }
    if str_eq(noun, "rafiki")  { return "rafiki" }
    if str_eq(noun, "daktari") { return "madaktari" }  // some use ma- pl
    if str_eq(noun, "habari")  { return "habari" }
    if str_eq(noun, "nchi")    { return "nchi" }
    if str_eq(noun, "bahari")  { return "bahari" }
    if str_eq(noun, "shule")   { return "shule" }
    if str_eq(noun, "hospitali") { return "hospitali" }
    if str_eq(noun, "ofisi")   { return "ofisi" }
    if str_eq(noun, "serikali") { return "serikali" }

    // ── Productive rules ────────────────────────────────────────────────────

    // Class 1 (m- people): m- → wa-
    if sw_is_class1_noun(noun) {
        if str_eq(sw_str_first2(noun), "mw") {
            return "wa" + str_slice(noun, 2, str_len(noun))
        }
        if str_eq(sw_str_first_char(noun), "m") {
            return "wa" + str_slice(noun, 1, str_len(noun))
        }
    }

    // Class 7 (ki-/ch-) → Class 8 (vi-/vy-)
    let p2: String = sw_str_first2(noun)
    if str_eq(p2, "ki") {
        return "vi" + str_slice(noun, 2, str_len(noun))
    }
    if str_eq(p2, "ch") {
        return "vy" + str_slice(noun, 2, str_len(noun))
    }

    // Class 5 (ji-) → Class 6 (ma-)
    if str_eq(p2, "ji") {
        return "ma" + str_slice(noun, 2, str_len(noun))
    }

    // Class 11 (u-/w-) → Class 10 (n-/∅): drop u, may add n
    let p1: String = sw_str_first_char(noun)
    if str_eq(p1, "u") {
        // Most u- class nouns: drop u → bare stem (class 10 zero prefix)
        return str_slice(noun, 1, str_len(noun))
    }

    // Class 3 (m-/mw- inanimate) → Class 4 (mi-)
    if str_eq(p1, "m") {
        if str_eq(p2, "mw") {
            return "mi" + str_slice(noun, 2, str_len(noun))
        }
        return "mi" + str_slice(noun, 1, str_len(noun))
    }

    // Class 9/10: no prefix change (same form)
    return noun
}

// ── Adjective agreement ───────────────────────────────────────────────────────
//
// Adjectives in Swahili take a class agreement prefix that matches the noun
// they modify.  The prefix is placed before the adjective stem.
//
// Agreement prefixes (singular):
//   cl.1  → m-/mw-   cl.2  → wa-
//   cl.3  → m-/mw-   cl.4  → mi-
//   cl.5  → (j-)l-   cl.6  → ma-
//   cl.7  → ki-/ch-  cl.8  → vi-/vy-
//   cl.9  → (n-)     cl.10 → (n-)
//   cl.11 → mw-      cl.15 → ku-
//
// The adjective prefix for class 1/3 singular before a vowel-initial stem
// uses mw- instead of m-.
//
// number: "sg" | "pl"
// noun_class: singular class of the noun (the function applies the correct
//             plural class internally when number == "pl")

fn sw_adj_prefix(noun_class: String, number: String) -> String {
    // Plural classes
    if str_eq(number, "pl") {
        if str_eq(noun_class, "1") { return "wa" }   // cl.2
        if str_eq(noun_class, "2") { return "wa" }
        if str_eq(noun_class, "3") { return "mi" }   // cl.4
        if str_eq(noun_class, "4") { return "mi" }
        if str_eq(noun_class, "5") { return "ma" }   // cl.6
        if str_eq(noun_class, "6") { return "ma" }
        if str_eq(noun_class, "7") { return "vi" }   // cl.8
        if str_eq(noun_class, "8") { return "vi" }
        if str_eq(noun_class, "9") { return "n" }    // cl.10 (nasal)
        if str_eq(noun_class, "10") { return "n" }
        if str_eq(noun_class, "11") { return "n" }   // cl.10 in plural
        return "wa"
    }

    // Singular classes
    if str_eq(noun_class, "1")  { return "m" }
    if str_eq(noun_class, "3")  { return "m" }
    if str_eq(noun_class, "4")  { return "mi" }
    if str_eq(noun_class, "5")  { return "j" }   // l- before consonant, j- before vowel
    if str_eq(noun_class, "6")  { return "ma" }
    if str_eq(noun_class, "7")  { return "ki" }
    if str_eq(noun_class, "8")  { return "vi" }
    if str_eq(noun_class, "9")  { return "n" }
    if str_eq(noun_class, "10") { return "n" }
    if str_eq(noun_class, "11") { return "mw" }
    if str_eq(noun_class, "15") { return "ku" }
    return ""
}

// sw_agree_adj: apply the agreement prefix to an adjective stem.
//
// adj_stem:   the adjective without any class prefix (e.g. "zuri", "kubwa", "dogo")
// noun_class: class of the noun being modified (singular class number as string)
// number:     "sg" | "pl"
//
// Returns the fully prefixed adjective form.
//
// Note: many common adjectives in Swahili are Arabic/Bantu borrowings and do
// not take class prefixes (e.g. "nzuri" — beautiful, "kubwa" — big, "dogo" — small).
// Prefix agreement applies primarily to native Bantu adjective stems and
// demonstratives.  This function applies the prefix mechanically; for adjectives
// that are invariant loanwords the caller should use the bare form.

fn sw_agree_adj(adj_stem: String, noun_class: String, number: String) -> String {
    // Invariant adjectives (no class prefix required in standard usage)
    if str_eq(adj_stem, "nzuri")  { return "nzuri" }   // good/beautiful
    if str_eq(adj_stem, "baya")   { return "baya" }    // bad
    if str_eq(adj_stem, "safi")   { return "safi" }    // clean
    if str_eq(adj_stem, "chafu")  { return "chafu" }   // dirty
    if str_eq(adj_stem, "ghali")  { return "ghali" }   // expensive
    if str_eq(adj_stem, "rahisi") { return "rahisi" }  // cheap/easy
    if str_eq(adj_stem, "mzuri")  { return sw_adj_prefix(noun_class, number) + "zuri" }

    // Apply class prefix to Bantu adjective stems
    let prefix: String = sw_adj_prefix(noun_class, number)
    if str_eq(prefix, "") {
        return adj_stem
    }

    // cl.1/3 prefix m- before consonant, mw- before vowel
    if str_eq(prefix, "m") {
        let first: String = sw_str_first_char(adj_stem)
        if str_eq(first, "a") { return "mw" + adj_stem }
        if str_eq(first, "e") { return "mw" + adj_stem }
        if str_eq(first, "i") { return "mw" + adj_stem }
        if str_eq(first, "o") { return "mw" + adj_stem }
        if str_eq(first, "u") { return "mw" + adj_stem }
        return "m" + adj_stem
    }

    // cl.5 prefix j- before vowel, l- before consonant
    if str_eq(prefix, "j") {
        let first: String = sw_str_first_char(adj_stem)
        if str_eq(first, "a") { return "j" + adj_stem }
        if str_eq(first, "e") { return "j" + adj_stem }
        if str_eq(first, "i") { return "j" + adj_stem }
        if str_eq(first, "o") { return "j" + adj_stem }
        if str_eq(first, "u") { return "j" + adj_stem }
        return "l" + adj_stem
    }

    return prefix + adj_stem
}

// ── Demonstrative agreement ───────────────────────────────────────────────────
//
// Swahili demonstratives agree with the noun class.
// "this" (proximal): huyu (cl.1/2), huu (cl.3/11), hili (cl.5), hiki (cl.7),
//                    hii (cl.9), huu (cl.11)
// "that" (distal):   yule (cl.1/2), ule (cl.3/11), lile (cl.5), kile (cl.7),
//                    ile (cl.9)
//
// proximity: "near" | "far"

fn sw_demonstrative(noun_class: String, number: String, proximity: String) -> String {
    if str_eq(proximity, "near") {
        if str_eq(number, "pl") {
            if str_eq(noun_class, "1") { return "hawa" }
            if str_eq(noun_class, "3") { return "hii" }
            if str_eq(noun_class, "5") { return "haya" }
            if str_eq(noun_class, "7") { return "hivi" }
            if str_eq(noun_class, "9") { return "hizi" }
            return "hawa"
        }
        if str_eq(noun_class, "1")  { return "huyu" }
        if str_eq(noun_class, "3")  { return "huu" }
        if str_eq(noun_class, "5")  { return "hili" }
        if str_eq(noun_class, "7")  { return "hiki" }
        if str_eq(noun_class, "9")  { return "hii" }
        if str_eq(noun_class, "11") { return "huu" }
        if str_eq(noun_class, "15") { return "huku" }
        return "hii"
    }
    // distal
    if str_eq(number, "pl") {
        if str_eq(noun_class, "1") { return "wale" }
        if str_eq(noun_class, "3") { return "ile" }
        if str_eq(noun_class, "5") { return "yale" }
        if str_eq(noun_class, "7") { return "vile" }
        if str_eq(noun_class, "9") { return "zile" }
        return "wale"
    }
    if str_eq(noun_class, "1")  { return "yule" }
    if str_eq(noun_class, "3")  { return "ule" }
    if str_eq(noun_class, "5")  { return "lile" }
    if str_eq(noun_class, "7")  { return "kile" }
    if str_eq(noun_class, "9")  { return "ile" }
    if str_eq(noun_class, "11") { return "ule" }
    if str_eq(noun_class, "15") { return "kule" }
    return "ile"
}

// ── Swahili copula (kuwa — to be) ─────────────────────────────────────────────
//
// The copula in Swahili is complex:
//
// Equational ("X is Y", noun predicate):
//   ni (is/am/are) — invariant for present equational
//   si — negative present equational
//
// Locative/existential ("X is [somewhere]", with -ko/-po/-mo):
//   niko/uko/yuko/tuko/mko/wako — with -ko (definite location)
//   nipo/upo/yupo/tupo/mpo/wapo — with -po (near location)
//   nimo/umo/yumo/tumo/mmo/wamo — with -mo (inside)
//
// sw_copula_present: returns the present copula form.
// use_case: "equative" | "locative"

fn sw_copula_present(person: String, number: String, use_case: String) -> String {
    if str_eq(use_case, "equative") {
        if str_eq(person, "1") { return "ni" }
        if str_eq(person, "2") { return "ni" }
        return "ni"
    }
    // locative -ko (most common)
    if str_eq(person, "1") {
        if str_eq(number, "sg") { return "niko" }
        return "tuko"
    }
    if str_eq(person, "2") {
        if str_eq(number, "sg") { return "uko" }
        return "mko"
    }
    if str_eq(number, "sg") { return "yuko" }
    return "wako"
}

// sw_copula_neg_present: negative present copula.
// equative: si (invariant for all persons in negative equational)
fn sw_copula_neg_present(person: String, number: String) -> String {
    if str_eq(person, "1") {
        if str_eq(number, "sg") { return "si" }
        return "si"
    }
    if str_eq(person, "2") {
        if str_eq(number, "sg") { return "si" }
        return "si"
    }
    return "si"
}