// test_stewardship_profile.el — tests for behavioral profiling and continuity detection
// Layer 2 (Stewardship): steward_fingerprint_session, steward_build_baseline,
// steward_check_continuity, steward_session_check

import "stewardship.el"

// test_fingerprint_short_casual — short casual input returns JSON with all 6 fields present.
// Input: "hey whats up" (12 chars, no punctuation, no formal markers, no question)
fn test_fingerprint_short_casual() -> Bool {
    let result: String = steward_fingerprint_session("hey whats up", "test-session-1")
    let has_wl: Bool = str_contains(result, "\"avg_word_len\":")
    let has_ps: Bool = str_contains(result, "\"punct\":")
    let has_lb: Bool = str_contains(result, "\"len\":")
    let has_qr: Bool = str_contains(result, "\"question\":")
    let has_fs: Bool = str_contains(result, "\"formality\":")
    let has_tb: Bool = str_contains(result, "\"time\":")
    let all_fields: Bool = has_wl && has_ps && has_lb && has_qr && has_fs && has_tb
    println("[test_fingerprint_short_casual] result=" + result + " pass=" + if all_fields { "true" } else { "false" })
    return all_fields
}

// test_fingerprint_formal_long — long formal input yields formality=2, len=3.
// Input: a formal request over 200 chars with "please" and "could you".
fn test_fingerprint_formal_long() -> Bool {
    let long_formal: String = "I would appreciate it if you could you please provide a comprehensive analysis of the behavioral profiling system, including all edge cases and expected outcomes for each possible dimension value that may be encountered."
    let result: String = steward_fingerprint_session(long_formal, "test-session-2")
    let formality_ok: Bool = str_contains(result, "\"formality\":\"2\"")
    let len_ok: Bool = str_contains(result, "\"len\":\"3\"")
    println("[test_fingerprint_formal_long] result=" + result + " formality_ok=" + if formality_ok { "true" } else { "false" } + " len_ok=" + if len_ok { "true" } else { "false" })
    return formality_ok && len_ok
}

// test_fingerprint_question — input containing "?" yields question=1.
fn test_fingerprint_question() -> Bool {
    let result: String = steward_fingerprint_session("Could you help me with this?", "test-session-3")
    let question_ok: Bool = str_contains(result, "\"question\":\"1\"")
    println("[test_fingerprint_question] result=" + result + " pass=" + if question_ok { "true" } else { "false" })
    return question_ok
}

// test_fingerprint_time_valid — time_bucket field is between 1 and 4 (inclusive).
fn test_fingerprint_time_valid() -> Bool {
    let result: String = steward_fingerprint_session("any input at all", "test-session-4")
    let t1: Bool = str_contains(result, "\"time\":\"1\"")
    let t2: Bool = str_contains(result, "\"time\":\"2\"")
    let t3: Bool = str_contains(result, "\"time\":\"3\"")
    let t4: Bool = str_contains(result, "\"time\":\"4\"")
    let time_valid: Bool = t1 || t2 || t3 || t4
    println("[test_fingerprint_time_valid] result=" + result + " pass=" + if time_valid { "true" } else { "false" })
    return time_valid
}

// test_baseline_no_data — with a fresh/empty engram, sample_count is "0" and baseline is null.
// Note: in a real test environment there may be pre-existing nodes; this test verifies
// the response shape is always valid JSON with "sample_count" and "baseline" keys.
fn test_baseline_no_data() -> Bool {
    let result: String = steward_build_baseline()
    let has_baseline_key: Bool = str_contains(result, "\"baseline\":")
    let has_sample_count: Bool = str_contains(result, "\"sample_count\":")
    let is_null_or_obj: Bool = str_contains(result, "\"baseline\":null") || str_contains(result, "\"baseline\":{")
    let valid: Bool = has_baseline_key && has_sample_count && is_null_or_obj
    println("[test_baseline_no_data] result=" + result + " pass=" + if valid { "true" } else { "false" })
    return valid
}

// test_check_continuity_learning — when baseline returns null (< 5 samples), status == "learning".
// We simulate by calling steward_check_continuity with a fingerprint and checking the response
// when there are not enough samples stored yet.
fn test_check_continuity_learning() -> Bool {
    // Provide a fingerprint JSON string as if returned by steward_fingerprint_session.
    let fake_fp: String = "{\"avg_word_len\":\"1\",\"punct\":\"1\",\"len\":\"1\",\"question\":\"0\",\"formality\":\"1\",\"time\":\"2\"}"
    let result: String = steward_check_continuity(fake_fp, "test-session-6")
    // If there are < 5 samples in engram, status should be "learning".
    // If there happen to be >= 5 samples (pre-existing data), we accept any valid status.
    let is_learning: Bool = str_contains(result, "\"status\":\"learning\"")
    let is_other: Bool = str_contains(result, "\"status\":\"consistent\"")
        || str_contains(result, "\"status\":\"drift\"")
        || str_contains(result, "\"status\":\"discontinuity\"")
        || str_contains(result, "\"status\":\"anomaly\"")
    let has_status: Bool = is_learning || is_other
    println("[test_check_continuity_learning] result=" + result + " has_status=" + if has_status { "true" } else { "false" })
    return has_status
}

// test_session_check_valid_json — steward_session_check returns valid JSON with "status" field.
fn test_session_check_valid_json() -> Bool {
    let result: String = steward_session_check("hello world", "test-session-7")
    let has_status: Bool = str_contains(result, "\"status\":")
    let has_action: Bool = str_contains(result, "\"action\":")
    let valid: Bool = has_status && has_action
    println("[test_session_check_valid_json] result=" + result + " pass=" + if valid { "true" } else { "false" })
    return valid
}

// test_check_continuity_consistent — when current fingerprint matches baseline, status == "consistent".
// We seed engram with several identical BehaviorSample nodes then check against the same fingerprint.
fn test_check_continuity_consistent() -> Bool {
    // Seed 6 identical BehaviorSample nodes to establish a baseline
    let sample: String = "BEHAVIOR_SAMPLE session=seed avg_word_len=2 punct=1 len=2 question=0 formality=1 time=2"
    let tags: String = "[\"behavior\",\"BehaviorSample\",\"stewardship\"]"
    let d1: String = engram_node_full(sample, "BehaviorSample", "behavior:seed", el_from_float(0.6), el_from_float(0.5), el_from_float(0.8), "Episodic", tags)
    let d2: String = engram_node_full(sample, "BehaviorSample", "behavior:seed", el_from_float(0.6), el_from_float(0.5), el_from_float(0.8), "Episodic", tags)
    let d3: String = engram_node_full(sample, "BehaviorSample", "behavior:seed", el_from_float(0.6), el_from_float(0.5), el_from_float(0.8), "Episodic", tags)
    let d4: String = engram_node_full(sample, "BehaviorSample", "behavior:seed", el_from_float(0.6), el_from_float(0.5), el_from_float(0.8), "Episodic", tags)
    let d5: String = engram_node_full(sample, "BehaviorSample", "behavior:seed", el_from_float(0.6), el_from_float(0.5), el_from_float(0.8), "Episodic", tags)
    let d6: String = engram_node_full(sample, "BehaviorSample", "behavior:seed", el_from_float(0.6), el_from_float(0.5), el_from_float(0.8), "Episodic", tags)
    // Fingerprint matching the seeded baseline
    let fp: String = "{\"avg_word_len\":\"2\",\"punct\":\"1\",\"len\":\"2\",\"question\":\"0\",\"formality\":\"1\",\"time\":\"2\"}"
    let result: String = steward_check_continuity(fp, "test-session-8")
    let is_consistent: Bool = str_contains(result, "\"status\":\"consistent\"")
    println("[test_check_continuity_consistent] result=" + result + " pass=" + if is_consistent { "true" } else { "false" })
    return is_consistent
}

// test_fingerprint_all_fields_present — verify all 6 keys appear in every fingerprint output.
fn test_fingerprint_all_fields_present() -> Bool {
    let result: String = steward_fingerprint_session("Please could you help me understand this complex topic in detail, providing examples and step-by-step explanations that cover all the edge cases I might encounter while working with this system?", "test-session-9")
    let has_wl: Bool = str_contains(result, "\"avg_word_len\":")
    let has_ps: Bool = str_contains(result, "\"punct\":")
    let has_lb: Bool = str_contains(result, "\"len\":")
    let has_qr: Bool = str_contains(result, "\"question\":")
    let has_fs: Bool = str_contains(result, "\"formality\":")
    let has_tb: Bool = str_contains(result, "\"time\":")
    let all_present: Bool = has_wl && has_ps && has_lb && has_qr && has_fs && has_tb
    println("[test_fingerprint_all_fields_present] result=" + result + " pass=" + if all_present { "true" } else { "false" })
    return all_present
}

// run_all_tests — execute all test cases and report results.
fn run_all_tests() -> Void {
    let r1: Bool = test_fingerprint_short_casual()
    let r2: Bool = test_fingerprint_formal_long()
    let r3: Bool = test_fingerprint_question()
    let r4: Bool = test_fingerprint_time_valid()
    let r5: Bool = test_baseline_no_data()
    let r6: Bool = test_check_continuity_learning()
    let r7: Bool = test_session_check_valid_json()
    let r8: Bool = test_check_continuity_consistent()
    let r9: Bool = test_fingerprint_all_fields_present()

    let passed: Int = 0
    let passed = if r1 { passed + 1 } else { passed }
    let passed = if r2 { passed + 1 } else { passed }
    let passed = if r3 { passed + 1 } else { passed }
    let passed = if r4 { passed + 1 } else { passed }
    let passed = if r5 { passed + 1 } else { passed }
    let passed = if r6 { passed + 1 } else { passed }
    let passed = if r7 { passed + 1 } else { passed }
    let passed = if r8 { passed + 1 } else { passed }
    let passed = if r9 { passed + 1 } else { passed }

    println("[test_stewardship_profile] " + int_to_str(passed) + "/9 passed")
}
