cartulary 0.3.0-alpha.1

use crate::domain::model::issue::IssueEdit;
use crate::domain::model::record_ref::IssueRef;
use crate::domain::model::title::Title;
use crate::domain::usecases::edit::issue::commit_issue_edits;
use crate::domain::usecases::issue::IssueRepository;

/// Outcome of an `edit_issue_title` call.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EditIssueTitleOutcome {
    /// The title was changed and saved.
    Updated,
    /// The new title equals the current one — no write was performed.
    NoOp,
}

/// Replace the title of an existing issue.
///
/// Title edits are not tracked in the event log — git history is the audit
/// trail (per DDR-018QWJVHRH35B, only status transitions are journalled).
/// Returns `Err` if the issue is not found.
pub fn edit_issue_title(
    repo: &dyn IssueRepository,
    id: &IssueRef,
    new_title: Title,
) -> anyhow::Result<EditIssueTitleOutcome> {
    let issue = repo
        .find_by_id(id)?
        .ok_or_else(|| anyhow::anyhow!("issue {id} not found"))?;
    if issue.title == new_title {
        return Ok(EditIssueTitleOutcome::NoOp);
    }
    commit_issue_edits(
        repo,
        vec![IssueEdit::SetTitle {
            issue: id.clone(),
            title: new_title,
        }],
    )?;
    Ok(EditIssueTitleOutcome::Updated)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::domain::usecases::issue::tests::{feature, FakeIssueRepository, IssueFixture};

    #[test]
    fn changing_the_title_saves_the_new_value() {
        scenario()
            .given(feature("Old name").with_id("ISSUE-0001"))
            .when_edit_title("ISSUE-0001", "New name")
            .then_saved_title("New name")
            .then_updated();
    }

    #[test]
    fn submitting_the_same_title_is_a_noop() {
        scenario()
            .given(feature("Stable").with_id("ISSUE-0001"))
            .when_edit_title("ISSUE-0001", "Stable")
            .then_noop();
    }

    #[test]
    fn editing_the_title_of_an_unknown_issue_returns_an_error() {
        scenario()
            .when_edit_title("ISSUE-0099", "Whatever")
            .then_err_contains("not found");
    }

    fn scenario() -> Scenario {
        Scenario {
            repo: FakeIssueRepository::new(),
        }
    }

    struct Scenario {
        repo: FakeIssueRepository,
    }

    impl Scenario {
        fn given(mut self, fixture: IssueFixture) -> Self {
            let raw = fixture
                .id
                .as_deref()
                .expect("given() requires an explicit id — use .with_id()")
                .to_string();
            let numeric = IssueRef::new(&raw).unwrap();
            self.repo.push_issue(fixture.build(numeric));
            self
        }

        fn when_edit_title(self, id: &str, new_title: &str) -> EditOutcome {
            let issue_ref = IssueRef::new(id).unwrap();
            let result = edit_issue_title(&self.repo, &issue_ref, Title::new(new_title).unwrap());
            EditOutcome {
                repo: self.repo,
                result,
            }
        }
    }

    struct EditOutcome {
        repo: FakeIssueRepository,
        result: anyhow::Result<EditIssueTitleOutcome>,
    }

    impl EditOutcome {
        fn then_saved_title(self, expected: &str) -> Self {
            let saved = self.repo.last_saved().expect("expected a save, got none");
            assert_eq!(saved.title.as_str(), expected);
            self
        }

        fn then_updated(self) -> Self {
            assert_eq!(
                self.result.as_ref().expect("expected Ok, got Err"),
                &EditIssueTitleOutcome::Updated
            );
            self
        }

        fn then_noop(self) -> Self {
            assert_eq!(
                self.result.as_ref().expect("expected Ok, got Err"),
                &EditIssueTitleOutcome::NoOp
            );
            assert!(self.repo.last_saved().is_none(), "expected nothing saved");
            self
        }

        fn then_err_contains(self, substring: &str) {
            let msg = self.result.expect_err("expected Err, got Ok").to_string();
            assert!(
                msg.contains(substring),
                "expected {substring:?}, got {msg:?}"
            );
        }
    }
}