//
use derive_more::Display;

use git_next_core::{
    git::{forge::commit::Status, Commit, UserNotification},
    message, newtype, ForgeNotification, RegisteredWebhook, RepoConfig, WebhookAuth, WebhookId,
};

message!(
    LoadConfigFromRepo,
    "Request to load the `git-next.toml` from the git repo."
);
message!(CloneRepo, "Request to clone (or open) the git repo.");
message!(
    ReceiveRepoConfig,
    RepoConfig,
    r#"Notification that the `git-next.toml` file has been loaded from the repo and parsed.

Contains the parsed contents of the `git-next.toml` file."#
);
message!(
    ValidateRepo,
    MessageToken,
    r#"Request that the state of the branches in the git repo be assessed and generate any followup actions.

This is the main function of `git-next` where decisions are made on what branches need to be updated and when.

Contains a [MessageToken] to reduce duplicate messages being sent. Only messages with the latest [MessageToken] are handled,
all others are dropped."#
);

message!(
    WebhookRegistered,
    (WebhookId, WebhookAuth),
    r#"Notification that a webhook has been registered with a forge.

Contains a tuple of the ID for the webhook returned from the forge, and the unique authorisation token that
incoming messages from the forge must provide."#
);
impl WebhookRegistered {
    pub const fn webhook_id(&self) -> &WebhookId {
        &self.0 .0
    }
    pub const fn webhook_auth(&self) -> &WebhookAuth {
        &self.0 .1
    }
}
impl From<RegisteredWebhook> for WebhookRegistered {
    fn from(value: RegisteredWebhook) -> Self {
        let webhook_id = value.id().clone();
        let webhook_auth = value.auth().clone();
        Self::from((webhook_id, webhook_auth))
    }
}

message!(
    UnRegisterWebhook,
    "Request that the webhook be removed from the forge, so they will stop notifying us."
);

newtype!(
    MessageToken,
    u32,
    Copy,
    Default,
    Display,
    PartialOrd,
    Ord,
    r#"An incremental token used to identify the current set of messages.

Primarily used by [ValidateRepo] to reduce duplicate messages. The token is incremented when a new Webhook message is
received, marking that message the latest, and causing any previous messages still being processed to be dropped when
they next send a [ValidateRepo] message."#
);
impl MessageToken {
    pub const fn next(self) -> Self {
        Self(self.0 + 1)
    }
}

message!(
    RegisterWebhook,
    "Requests that a Webhook be registered with the forge."
);
message!(
    CheckCIStatus,
    Commit,
    r#"Requests that the CI status for the commit be checked.

Once the CI Status has been received it will be sent via a [ReceiveCIStatus] message.

Contains the commit from the tip of the `next` branch."#
); // next commit
message!(
    ReceiveCIStatus,
    (Commit, Status),
    r#"Notification of the status of the CI checks for the commit.

Contains a tuple of the commit that was checked (the tip of the `next` branch) and the status."#
); // commit and it's status

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AdvanceNextPayload {
    pub next: Commit,
    pub main: Commit,
    pub dev_commit_history: Vec<Commit>,
}
message!(
    AdvanceNext,
    AdvanceNextPayload,
    "Request to advance the `next` branch on to the next commit on the `dev branch."
); // next commit and the dev commit history
message!(
    AdvanceMain,
    Commit,
    "Request to advance the `main` branch on to same commit as the `next` branch."
); // next commit
message!(
    WebhookNotification,
    ForgeNotification,
    "Notification of a webhook message from the forge."
);
message!(
    NotifyUser,
    UserNotification,
    "Request to send the message payload to the notification webhook"
);