use db::repo::repos;
use gitsync::{PostReceiveRefUpdate, PostReceiveTask};
use serde_json::json;

#[must_use]
pub fn build_push_payload(
    task: &PostReceiveTask,
    repo: &repos::Model,
    update: &PostReceiveRefUpdate,
) -> serde_json::Value {
    let pusher_id = task.actor_id.map_or_else(String::new, |id| id.to_string());
    json!({
        "ref": update.name,
        "before": update.old_oid,
        "after": update.new_oid,
        "created": update.is_create(),
        "deleted": update.is_delete(),
        "pusher": { "id": pusher_id },
        "sender": { "id": pusher_id },
        "repository": {
            "id": repo.id.to_string(),
            "name": repo.name,
            "full_name": format!("{}/{}", repo.channel_id, repo.name),
            "default_branch": repo.default_branch,
            "channel_id": repo.channel_id.to_string(),
        },
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use gitsync::PostReceiveRefUpdate;
    use time::OffsetDateTime;
    use uuid::Uuid;

    fn sample_task() -> PostReceiveTask {
        let refs = vec![PostReceiveRefUpdate::new(
            "refs/heads/main",
            "0000000000000000000000000000000000000000",
            "1111111111111111111111111111111111111111",
        )];
        PostReceiveTask::new(Uuid::now_v7(), Uuid::now_v7(), Some(Uuid::now_v7()), refs)
    }

    fn sample_repo() -> repos::Model {
        repos::Model {
            id: Uuid::now_v7(),
            channel_id: Uuid::now_v7(),
            lower_name: "demo".into(),
            name: "demo".into(),
            description: None,
            website: None,
            default_branch: "main".into(),
            nums_watch: 0,
            nums_star: 0,
            nums_pr: 0,
            nums_commits: 0,
            nums_branches: 0,
            nums_tags: 0,
            enable_lfs: false,
            is_private: false,
            is_archived: false,
            storage_limit_size: None,
            size: 0,
            git_size: 0,
            lfs_size: 0,
            avatar_url: None,
            primary_language: None,
            license_name: None,
            created_at: OffsetDateTime::now_utc(),
            last_pushed_at: None,
            archived_at: None,
            readme_raw: None,
            allow_rebase: true,
            allow_rebase_explicit: false,
            allow_squash_merge: true,
            allow_merge_commits: true,
            object_format: "sha1".into(),
        }
    }

    #[test]
    fn payload_has_core_fields() {
        let task = sample_task();
        let repo = sample_repo();
        let payload = build_push_payload(&task, &repo, &task.refs[0]);
        assert_eq!(payload["ref"], "refs/heads/main");
        assert_eq!(payload["created"], true);
        assert_eq!(payload["deleted"], false);
        assert_eq!(payload["repository"]["name"], "demo");
        assert_eq!(payload["repository"]["default_branch"], "main");
        assert_eq!(payload["repository"]["id"], repo.id.to_string());
        assert_eq!(payload["pusher"]["id"], task.actor_id.unwrap().to_string());
    }

    #[test]
    fn payload_flags_follow_ref_semantics() {
        let task = sample_task();
        let repo = sample_repo();
        let del = build_push_payload(
            &task,
            &repo,
            &PostReceiveRefUpdate::new(
                "refs/heads/main",
                "1111111111111111111111111111111111111111",
                "0000000000000000000000000000000000000000",
            ),
        );
        assert_eq!(del["deleted"], true);
        assert_eq!(del["created"], false);
    }
}