use serde::{Deserialize, Serialize};

use crate::{
    error::{OperationError, RepositoryError},
    object::Object,
    object_backend::ObjectBackend,
    operation::GiteratedOperation,
};

use super::{IssueLabel, Repository, RepositoryIssue, RepositoryTreeEntry, RepositoryView};

/// A request to get a repository's information.
///
/// # Authentication
/// - Instance Authentication
///   - Validate request against the `issued_for` public key
///   - Validate User token against the user's instance's public key
/// # Authorization
/// - User Authorization
///   - Potential User permissions checks
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct RepositoryInfoRequest;

impl GiteratedOperation<Repository> for RepositoryInfoRequest {
    type Success = RepositoryView;
    type Failure = RepositoryError;
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct RepositoryIssuesCountRequest;

impl GiteratedOperation<Repository> for RepositoryIssuesCountRequest {
    type Success = u64;
    type Failure = RepositoryError;
}

/// A request to get a repository's issues count.
///
/// # Authentication
/// - Instance Authentication
///   - Validate request against the `issued_for` public key
///   - Validate User token against the user's instance's public key
/// # Authorization
/// - User Authorization
///   - Potential User permissions checks
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct RepositoryIssueLabelsRequest;

impl GiteratedOperation<Repository> for RepositoryIssueLabelsRequest {
    type Success = Vec<IssueLabel>;
    type Failure = RepositoryError;
}

/// A request to get a repository's issue labels.
///
/// # Authentication
/// - Instance Authentication
///   - Validate request against the `issued_for` public key
///   - Validate User token against the user's instance's public key
/// # Authorization
/// - User Authorization
///   - Potential User permissions checks
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct RepositoryIssuesRequest;

impl GiteratedOperation<Repository> for RepositoryIssuesRequest {
    type Success = Vec<RepositoryIssue>;
    type Failure = RepositoryError;
}

/// A request to inspect the tree of a repository.
///
/// # Authentication
/// - Instance Authentication
///   - Validate request against the `issued_for` public key
///   - Validate User token against the user's instance's public key
/// # Authorization
/// - User Authorization
///   - Potential User permissions checks
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct RepositoryFileInspectRequest {
    pub path: RepositoryTreeEntry,
}

impl GiteratedOperation<Repository> for RepositoryFileInspectRequest {
    type Success = Vec<RepositoryTreeEntry>;
    type Failure = RepositoryError;
}

impl<B: ObjectBackend + std::fmt::Debug> Object<'_, Repository, B> {
    pub async fn info(&mut self) -> Result<RepositoryView, OperationError<RepositoryError>> {
        self.request::<RepositoryInfoRequest>(RepositoryInfoRequest)
            .await
    }
    // pub async fn issues_count(&mut self) -> Result<u64, OperationError<RepositoryError>> {
    //     self.request::<RepositoryIssuesCountRequest>(RepositoryIssuesCountRequest)
    //         .await
    // }

    pub async fn issue_labels(
        &mut self,
    ) -> Result<Vec<IssueLabel>, OperationError<RepositoryError>> {
        self.request::<RepositoryIssueLabelsRequest>(RepositoryIssueLabelsRequest)
            .await
    }

    pub async fn issues(
        &mut self,
    ) -> Result<Vec<RepositoryIssue>, OperationError<RepositoryError>> {
        self.request::<RepositoryIssuesRequest>(RepositoryIssuesRequest)
            .await
    }

    pub async fn inspect_files(
        &mut self,
        entry: &RepositoryTreeEntry,
    ) -> Result<Vec<RepositoryTreeEntry>, OperationError<RepositoryError>> {
        self.request::<RepositoryFileInspectRequest>(RepositoryFileInspectRequest {
            path: entry.clone(),
        })
        .await
    }
}