1use async_trait::async_trait;
2use std::io::Write;
3use std::process::{Command, Stdio};
4
5use crate::dto::GitHttpResponse;
6use crate::error::GitHttpError;
7use crate::util::git::REPO_SUFFIX;
8
9#[async_trait]
10pub trait GitHttpClient: Send + Sync + Clone + 'static {
11    async fn info_refs(
12        &self,
13        owner: &str,
14        repo: &str,
15        service: &str,
16    ) -> Result<GitHttpResponse, GitHttpError>;
17
18    async fn service_rpc(
19        &self,
20        owner: &str,
21        repo: &str,
22        service: &str,
23        content_type: &str,
24        body: &[u8],
25    ) -> Result<GitHttpResponse, GitHttpError>;
26
27    fn normalize_repo_name(&self, repo_name: &str) -> String {
28        format!(
29            "{}{}",
30            repo_name.strip_suffix(REPO_SUFFIX).unwrap_or(repo_name),
31            REPO_SUFFIX
32        )
33    }
34}
35
36#[derive(Debug, Clone)]
37pub struct GitHttpClientImpl {
38    project_root: String,
39}
40
41impl GitHttpClientImpl {
42    pub fn new(project_root: String) -> Self {
43        Self { project_root }
44    }
45
46    fn parse_cgi_response(&self, output: Vec<u8>) -> Result<GitHttpResponse, GitHttpError> {
47        let separator_pos = self.find_header_separator(&output).ok_or_else(|| {
48            GitHttpError::InvalidCgiResponse("Missing header/body separator".to_string())
49        })?;
50
51        let (header_section, rest) = output.split_at(separator_pos.0);
52        let body = &rest[separator_pos.1..];
53
54        let headers_str = String::from_utf8_lossy(header_section);
55        let mut headers = Vec::new();
56        let mut status_code = 200u16;
57
58        for line in headers_str.lines() {
59            if let Some((name, value)) = line.split_once(": ") {
60                if name.eq_ignore_ascii_case("Status") {
61                    if let Some(code_str) = value.split_whitespace().next() {
62                        status_code = code_str.parse().unwrap_or(200);
63                    }
64                } else {
65                    headers.push((name.to_string(), value.to_string()));
66                }
67            }
68        }
69
70        Ok(GitHttpResponse {
71            status_code,
72            headers,
73            body: body.to_vec(),
74        })
75    }
76
77    fn find_header_separator(&self, data: &[u8]) -> Option<(usize, usize)> {
78        // Look for \r\n\r\n first
79        for i in 0..data.len().saturating_sub(3) {
80            if &data[i..i + 4] == b"\r\n\r\n" {
81                return Some((i, 4));
82            }
83        }
84        // Fall back to \n\n
85        for i in 0..data.len().saturating_sub(1) {
86            if &data[i..i + 2] == b"\n\n" {
87                return Some((i, 2));
88            }
89        }
90        None
91    }
92}
93
94#[async_trait]
95impl GitHttpClient for GitHttpClientImpl {
96    async fn info_refs(
97        &self,
98        owner: &str,
99        repo: &str,
100        service: &str,
101    ) -> Result<GitHttpResponse, GitHttpError> {
102        let repo_name = self.normalize_repo_name(repo);
103
104        let child = Command::new("git")
105            .arg("http-backend")
106            .env("REQUEST_METHOD", "GET")
107            .env("PATH_INFO", format!("/{}/{}/info/refs", owner, repo_name))
108            .env("QUERY_STRING", format!("service={}", service))
109            .env("GIT_PROJECT_ROOT", &self.project_root)
110            .env("GIT_HTTP_EXPORT_ALL", "1")
111            .stdin(Stdio::null())
112            .stdout(Stdio::piped())
113            .stderr(Stdio::piped())
114            .spawn()
115            .map_err(GitHttpError::SpawnError)?;
116
117        let output = child.wait_with_output().map_err(GitHttpError::ReadError)?;
118
119        if !output.status.success() {
120            return Err(GitHttpError::ProcessFailed {
121                code: output.status.code().unwrap_or(-1),
122                stderr: String::from_utf8_lossy(&output.stderr).to_string(),
123            });
124        }
125
126        self.parse_cgi_response(output.stdout)
127    }
128
129    async fn service_rpc(
130        &self,
131        owner: &str,
132        repo: &str,
133        service: &str,
134        content_type: &str,
135        body: &[u8],
136    ) -> Result<GitHttpResponse, GitHttpError> {
137        let repo_name = self.normalize_repo_name(repo);
138
139        let mut child = Command::new("git")
140            .arg("http-backend")
141            .env("REQUEST_METHOD", "POST")
142            .env(
143                "PATH_INFO",
144                format!("/{}/{}/git-{}", owner, repo_name, service),
145            )
146            .env("CONTENT_TYPE", content_type)
147            .env("CONTENT_LENGTH", body.len().to_string())
148            .env("GIT_PROJECT_ROOT", &self.project_root)
149            .env("GIT_HTTP_EXPORT_ALL", "1")
150            .stdin(Stdio::piped())
151            .stdout(Stdio::piped())
152            .stderr(Stdio::piped())
153            .spawn()
154            .map_err(GitHttpError::SpawnError)?;
155
156        if let Some(mut stdin) = child.stdin.take() {
157            stdin.write_all(body).map_err(GitHttpError::WriteError)?;
158            drop(stdin);
159        }
160
161        let output = child.wait_with_output().map_err(GitHttpError::ReadError)?;
162
163        if !output.status.success() {
164            return Err(GitHttpError::ProcessFailed {
165                code: output.status.code().unwrap_or(-1),
166                stderr: String::from_utf8_lossy(&output.stderr).to_string(),
167            });
168        }
169
170        self.parse_cgi_response(output.stdout)
171    }
172}
173