pub mod discovery;
pub mod git;
pub mod github;
pub mod user;

use anyhow::Error;
use async_trait::async_trait;
use serde_json::Value;

use crate::backend::git::GitBackendError;
use giterated_models::{
    messages::{
        authentication::{
            AuthenticationTokenRequest, AuthenticationTokenResponse, RegisterAccountRequest,
            RegisterAccountResponse,
        },
        repository::{
            RepositoryCreateRequest, RepositoryCreateResponse, RepositoryFileInspectRequest,
            RepositoryFileInspectionResponse, RepositoryInfoRequest, RepositoryIssueLabelsRequest,
            RepositoryIssueLabelsResponse, RepositoryIssuesCountRequest,
            RepositoryIssuesCountResponse, RepositoryIssuesRequest, RepositoryIssuesResponse,
        },
        user::{
            UserBioRequest, UserBioResponse, UserDisplayImageRequest, UserDisplayImageResponse,
            UserDisplayNameRequest, UserDisplayNameResponse,
        },
    },
    model::{
        repository::{RepositorySummary, RepositoryView},
        user::User,
    },
};

#[async_trait]
pub trait RepositoryBackend: IssuesBackend {
    async fn create_repository(
        &mut self,
        user: &User,
        request: &RepositoryCreateRequest,
    ) -> Result<RepositoryCreateResponse, GitBackendError>;
    async fn repository_info(
        &mut self,
        requester: Option<&User>,
        request: &RepositoryInfoRequest,
    ) -> Result<RepositoryView, Error>;
    async fn repository_file_inspect(
        &mut self,
        requester: Option<&User>,
        request: &RepositoryFileInspectRequest,
    ) -> Result<RepositoryFileInspectionResponse, Error>;
    async fn repositories_for_user(
        &mut self,
        requester: Option<&User>,
        user: &User,
    ) -> Result<Vec<RepositorySummary>, Error>;
}

pub trait IssuesBackend {
    fn issues_count(
        &mut self,
        requester: Option<&User>,
        request: &RepositoryIssuesCountRequest,
    ) -> Result<RepositoryIssuesCountResponse, Error>;
    fn issue_labels(
        &mut self,
        requester: Option<&User>,
        request: &RepositoryIssueLabelsRequest,
    ) -> Result<RepositoryIssueLabelsResponse, Error>;
    fn issues(
        &mut self,
        requester: Option<&User>,
        request: &RepositoryIssuesRequest,
    ) -> Result<RepositoryIssuesResponse, Error>;
}

#[async_trait::async_trait]
pub trait AuthBackend {
    async fn register(
        &mut self,
        request: RegisterAccountRequest,
    ) -> Result<RegisterAccountResponse, Error>;

    async fn login(
        &mut self,
        request: AuthenticationTokenRequest,
    ) -> Result<AuthenticationTokenResponse, Error>;
}

#[async_trait::async_trait]
pub trait UserBackend: AuthBackend {
    async fn display_name(
        &mut self,
        request: UserDisplayNameRequest,
    ) -> Result<UserDisplayNameResponse, Error>;

    async fn display_image(
        &mut self,
        request: UserDisplayImageRequest,
    ) -> Result<UserDisplayImageResponse, Error>;

    async fn bio(&mut self, request: UserBioRequest) -> Result<UserBioResponse, Error>;
    async fn exists(&mut self, user: &User) -> Result<bool, Error>;

    async fn settings(&mut self, user: &User) -> Result<Vec<(String, Value)>, Error>;
    async fn write_settings(
        &mut self,
        user: &User,
        settings: &[(String, Value)],
    ) -> Result<(), Error>;
}