1use std::collections::{HashMap, HashSet};
2
3use async_trait::async_trait;
4
5use crate::client::{Git2Client, GitClient};
6use crate::dto::{
7    CommitAuthorResponse, CreateRepositoryRequest, GetRepositoryCommitsRequest,
8    GetRepositoryFileCommitsRequest, GetRepositoryFileRequest, GetRepositoryPreviewRequest,
9    GetRepositoryTreeRequest, RepositoryCommitResponse, RepositoryCommitsResponse,
10    RepositoryFileResponse, RepositoryPreviewResponse, RepositoryResponse, RepositoryTreeResponse,
11};
12use crate::error::RepositoryError;
13use crate::model::RepositoryOwnerType;
14use crate::repository::{
15    OrganizationRepository, OrganizationRepositoryImpl, RepositoryRepository,
16    RepositoryRepositoryImpl, UserRepository, UserRepositoryImpl,
17};
18
19#[async_trait]
20pub trait RepositoryService: Send + Sync + 'static {
21    async fn create_repository(
22        &self,
23        request: CreateRepositoryRequest,
24    ) -> Result<RepositoryResponse, RepositoryError>;
25
26    async fn get_repository_tree(
27        &self,
28        request: GetRepositoryTreeRequest,
29    ) -> Result<RepositoryTreeResponse, RepositoryError>;
30
31    async fn get_repository_file(
32        &self,
33        request: GetRepositoryFileRequest,
34    ) -> Result<RepositoryFileResponse, RepositoryError>;
35
36    async fn get_repository_commits(
37        &self,
38        request: GetRepositoryCommitsRequest,
39    ) -> Result<RepositoryCommitsResponse, RepositoryError>;
40
41    async fn get_repository_file_commits(
42        &self,
43        request: GetRepositoryFileCommitsRequest,
44    ) -> Result<RepositoryCommitsResponse, RepositoryError>;
45
46    async fn get_repository_preview(
47        &self,
48        request: GetRepositoryPreviewRequest,
49    ) -> Result<RepositoryPreviewResponse, RepositoryError>;
50}
51
52#[derive(Debug, Clone)]
53pub struct RepositoryServiceImpl<G, O, R, U>
54where
55    G: GitClient,
56    O: OrganizationRepository,
57    R: RepositoryRepository,
58    U: UserRepository,
59{
60    git_client: G,
61    org_repo: O,
62    repo_repo: R,
63    user_repo: U,
64}
65
66impl
67    RepositoryServiceImpl<
68        Git2Client,
69        OrganizationRepositoryImpl,
70        RepositoryRepositoryImpl,
71        UserRepositoryImpl,
72    >
73{
74    pub fn new(
75        git_client: Git2Client,
76        org_repo: OrganizationRepositoryImpl,
77        repo_repo: RepositoryRepositoryImpl,
78        user_repo: UserRepositoryImpl,
79    ) -> Self {
80        Self {
81            git_client,
82            org_repo,
83            repo_repo,
84            user_repo,
85        }
86    }
87}
88
89impl<G, O, R, U> RepositoryServiceImpl<G, O, R, U>
90where
91    G: GitClient,
92    O: OrganizationRepository,
93    R: RepositoryRepository,
94    U: UserRepository,
95{
96    async fn enrich_commits_with_users(
97        &self,
98        commits: &mut [RepositoryCommitResponse],
99    ) -> Result<(), RepositoryError> {
100        let emails: Vec<_> = commits
101            .iter()
102            .map(|c| c.author.email.clone())
103            .filter(|e| !e.is_empty())
104            .collect::<HashSet<_>>()
105            .into_iter()
106            .collect();
107
108        if emails.is_empty() {
109            return Ok(());
110        }
111
112        let users = self.user_repo.get_by_emails(&emails).await?;
113        let email_to_user: HashMap<_, _> = users.iter().map(|u| (u.email.as_str(), u)).collect();
114        for commit in commits {
115            if let Some(user) = email_to_user.get(commit.author.email.as_str()) {
116                commit.author = CommitAuthorResponse {
117                    id: Some(user.id),
118                    name: user.name.clone(),
119                    email: commit.author.email.clone(),
120                };
121            }
122        }
123
124        Ok(())
125    }
126}
127
128#[async_trait]
129impl<G, O, R, U> RepositoryService for RepositoryServiceImpl<G, O, R, U>
130where
131    G: GitClient,
132    O: OrganizationRepository,
133    R: RepositoryRepository,
134    U: UserRepository,
135{
136    async fn create_repository(
137        &self,
138        request: CreateRepositoryRequest,
139    ) -> Result<RepositoryResponse, RepositoryError> {
140        let repo_name = request.name.to_string();
141        if self
142            .git_client
143            .repo_exists(&request.owner_name, &repo_name)
144            .await
145        {
146            return Err(RepositoryError::Duplicate(repo_name));
147        }
148
149        let owner_id = match request.owner_type {
150            RepositoryOwnerType::User => request.user_id,
151            RepositoryOwnerType::Organization => {
152                let org = self
153                    .org_repo
154                    .get(&request.owner_name)
155                    .await?
156                    .ok_or_else(|| {
157                        RepositoryError::OwnerNotFound(request.owner_name.to_string())
158                    })?;
159                org.id
160            }
161        };
162
163        // Create git repo first
164        self.git_client
165            .create_repo(&request.owner_name, &repo_name)
166            .await?;
167
168        // Insert into DB, delete git repo on failure
169        let repository = match self
170            .repo_repo
171            .create(
172                &repo_name,
173                owner_id,
174                &request.owner_name,
175                &request.owner_type,
176                &request.visibility,
177            )
178            .await
179        {
180            Ok(repo) => repo,
181            Err(e) => {
182                let _ = self
183                    .git_client
184                    .delete_repo(&request.owner_name, &repo_name)
185                    .await;
186                return Err(e.into());
187            }
188        };
189
190        Ok(repository.into())
191    }
192
193    async fn get_repository_tree(
194        &self,
195        request: GetRepositoryTreeRequest,
196    ) -> Result<RepositoryTreeResponse, RepositoryError> {
197        let mut response = self
198            .git_client
199            .get_repo_tree(&request.owner_name, &request.name, &request.ref_name)
200            .await?;
201
202        let mut commits: Vec<RepositoryCommitResponse> =
203            response.entries.iter().map(|e| e.commit.clone()).collect();
204        self.enrich_commits_with_users(&mut commits).await?;
205
206        for (entry, enriched_commit) in response.entries.iter_mut().zip(commits.into_iter()) {
207            entry.commit = enriched_commit;
208        }
209
210        Ok(response)
211    }
212
213    async fn get_repository_file(
214        &self,
215        request: GetRepositoryFileRequest,
216    ) -> Result<RepositoryFileResponse, RepositoryError> {
217        self.git_client
218            .get_repo_file(
219                &request.owner_name,
220                &request.name,
221                &request.ref_name,
222                &request.path,
223            )
224            .await
225            .map_err(|e| e.into())
226    }
227
228    async fn get_repository_commits(
229        &self,
230        request: GetRepositoryCommitsRequest,
231    ) -> Result<RepositoryCommitsResponse, RepositoryError> {
232        let mut response = self
233            .git_client
234            .get_repo_commits(
235                &request.owner_name,
236                &request.name,
237                &request.ref_name,
238                request.page,
239                request.per_page,
240            )
241            .await?;
242
243        self.enrich_commits_with_users(&mut response.commits)
244            .await?;
245
246        Ok(response)
247    }
248
249    async fn get_repository_file_commits(
250        &self,
251        request: GetRepositoryFileCommitsRequest,
252    ) -> Result<RepositoryCommitsResponse, RepositoryError> {
253        let mut response = self
254            .git_client
255            .get_repo_file_commits(
256                &request.owner_name,
257                &request.name,
258                &request.ref_name,
259                &request.path,
260                request.page,
261                request.per_page,
262            )
263            .await?;
264
265        self.enrich_commits_with_users(&mut response.commits)
266            .await?;
267
268        Ok(response)
269    }
270
271    async fn get_repository_preview(
272        &self,
273        request: GetRepositoryPreviewRequest,
274    ) -> Result<RepositoryPreviewResponse, RepositoryError> {
275        self.git_client
276            .get_repo_preview(
277                &request.owner_name,
278                &request.name,
279                &request.ref_name,
280                request.preview_lines,
281            )
282            .await
283            .map_err(|e| e.into())
284    }
285}
286