task_app_rust/src/infrastructure/api.rs

use std::path::PathBuf;

use reqwest::Client;
use yup_oauth2::{InstalledFlowAuthenticator, InstalledFlowReturnMethod, ApplicationSecret};

use crate::domain::models::*;

#[derive(Debug)]
pub enum ApiError {
    Network(String),
    Auth(String),
    Api(String),
}

impl std::fmt::Display for ApiError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ApiError::Network(s) => write!(f, "Network error: {}", s),
            ApiError::Auth(s) => write!(f, "Auth error: {}", s),
            ApiError::Api(s) => write!(f, "API error: {}", s),
        }
    }
}

impl std::error::Error for ApiError {}

pub struct ApiClient {
    client: Client,
    authenticator: InstalledFlowAuthenticator,
    token_path: PathBuf,
}

const SCOPES: &[&str] = &["https://www.googleapis.com/auth/tasks"];

impl ApiClient {
    pub async fn new(client_id: String, client_secret: String) -> Result<Self, ApiError> {
        let token_path = dirs::config_dir()
            .unwrap_or_else(|| PathBuf::from("."))
            .join("task_app")
            .join("token.json");

        if let Some(parent) = token_path.parent() {
            std::fs::create_dir_all(parent).ok();
        }

        let secret = ApplicationSecret {
            client_id,
            client_secret,
            auth_uri: "https://accounts.google.com/o/oauth2/v2/auth".to_string(),
            token_uri: "https://oauth2.googleapis.com/token".to_string(),
            redirect_uris: vec!["http://127.0.0.1:8080/".to_string()],
            client_email: String::new(),
            client_x509_cert_url: String::new(),
            project_id: String::new(),
            ..Default::default()
        };

        let authenticator = InstalledFlowAuthenticator::builder(
            secret,
            InstalledFlowReturnMethod::HTTPRedirect,
        )
        .persist_tokens_to_disk(token_path.clone())
        .build()
        .await
        .map_err(|e| ApiError::Auth(format!("Failed to build authenticator: {}", e)))?;

        Ok(Self {
            client: Client::new(),
            authenticator,
            token_path,
        })
    }

    pub fn has_token(&self) -> bool {
        self.token_path.exists()
    }

    pub async fn start_and_wait_for_auth(&self) -> Result<(), ApiError> {
        self.authenticator.token(SCOPES).await.map_err(|e| {
            ApiError::Auth(format!("Authorization failed: {}", e))
        })?;
        Ok(())
    }

    async fn get_token(&self) -> Result<String, ApiError> {
        let token = self
            .authenticator
            .token(SCOPES)
            .await
            .map_err(|e| ApiError::Auth(format!("Token error: {}", e)))?;
        Ok(token.as_str().to_string())
    }

    pub async fn fetch_lists(&self) -> Result<Vec<TaskList>, ApiError> {
        let token = self.get_token().await?;

        let resp = self
            .client
            .get("https://tasks.googleapis.com/tasks/v1/users/@me/lists")
            .bearer_auth(&token)
            .send()
            .await
            .map_err(|e| ApiError::Network(e.to_string()))?;

        let data: serde_json::Value = resp
            .json()
            .await
            .map_err(|e| ApiError::Api(e.to_string()))?;

        let empty = vec![];
        let items = data["items"].as_array().unwrap_or(&empty);
        let lists = items
            .iter()
            .map(|item| TaskList {
                id: item["id"].as_str().unwrap_or("").to_string(),
                title: item["title"].as_str().unwrap_or("").to_string(),
            })
            .collect();

        Ok(lists)
    }

    pub async fn fetch_tasks(&self, list_id: &str) -> Result<Vec<Task>, ApiError> {
        let token = self.get_token().await?;

        let url = format!(
            "https://tasks.googleapis.com/tasks/v1/lists/{}/tasks?showCompleted=true&showHidden=true",
            list_id
        );

        let resp = self
            .client
            .get(&url)
            .bearer_auth(&token)
            .send()
            .await
            .map_err(|e| ApiError::Network(e.to_string()))?;

        let data: serde_json::Value = resp
            .json()
            .await
            .map_err(|e| ApiError::Api(e.to_string()))?;

        let empty = vec![];
        let items = data["items"].as_array().unwrap_or(&empty);
        let tasks = items
            .iter()
            .enumerate()
            .map(|(i, item)| {
                let due_str = item["due"].as_str().and_then(|s| {
                    chrono::NaiveDateTime::parse_from_str(
                        &s.replace("T", " ")
                            .replace("Z", "")
                            .chars()
                            .take(16)
                            .collect::<String>(),
                        "%Y-%m-%d %H:%M",
                    )
                    .ok()
                });

                Task {
                    id: item["id"].as_str().unwrap_or("").to_string(),
                    list_id: list_id.to_string(),
                    title: item["title"].as_str().unwrap_or("").to_string(),
                    notes: item["notes"].as_str().map(|s| s.to_string()),
                    status: if item["status"].as_str() == Some("completed") {
                        TaskStatus::Completed
                    } else {
                        TaskStatus::NeedsAction
                    },
                    due: due_str,
                    position: i as i64,
                }
            })
            .collect();

        Ok(tasks)
    }

    pub async fn create_task(&self, list_id: &str, task: &Task) -> Result<(), ApiError> {
        let token = self.get_token().await?;

        let mut body = serde_json::json!({
            "title": task.title,
        });

        if let Some(ref notes) = task.notes {
            body["notes"] = serde_json::Value::String(notes.clone());
        }
        if let Some(due) = task.due {
            body["due"] =
                serde_json::Value::String(due.format("%Y-%m-%dT%H:%M:00.000Z").to_string());
        }
        if task.status == TaskStatus::Completed {
            body["status"] = serde_json::Value::String("completed".to_string());
        }

        let url = format!(
            "https://tasks.googleapis.com/tasks/v1/lists/{}/tasks",
            list_id
        );

        let resp = self
            .client
            .post(&url)
            .bearer_auth(&token)
            .json(&body)
            .send()
            .await
            .map_err(|e| ApiError::Network(e.to_string()))?;

        if !resp.status().is_success() {
            return Err(ApiError::Api(format!(
                "Create failed: {}",
                resp.status()
            )));
        }

        Ok(())
    }

    pub async fn update_task(&self, list_id: &str, task: &Task) -> Result<(), ApiError> {
        let token = self.get_token().await?;

        let mut body = serde_json::json!({
            "title": task.title,
        });

        if let Some(ref notes) = task.notes {
            body["notes"] = serde_json::Value::String(notes.clone());
        }
        if let Some(due) = task.due {
            body["due"] =
                serde_json::Value::String(due.format("%Y-%m-%dT%H:%M:00.000Z").to_string());
        }
        body["status"] = serde_json::Value::String(match task.status {
            TaskStatus::Completed => "completed".to_string(),
            TaskStatus::NeedsAction => "needsAction".to_string(),
        });

        let url = format!(
            "https://tasks.googleapis.com/tasks/v1/lists/{}/tasks/{}",
            list_id, task.id
        );

        let resp = self
            .client
            .patch(&url)
            .bearer_auth(&token)
            .json(&body)
            .send()
            .await
            .map_err(|e| ApiError::Network(e.to_string()))?;

        if !resp.status().is_success() {
            return Err(ApiError::Api(format!(
                "Update failed: {}",
                resp.status()
            )));
        }

        Ok(())
    }

    pub async fn delete_task(&self, list_id: &str, task_id: &str) -> Result<(), ApiError> {
        let token = self.get_token().await?;

        let url = format!(
            "https://tasks.googleapis.com/tasks/v1/lists/{}/tasks/{}",
            list_id, task_id
        );

        let resp = self
            .client
            .delete(&url)
            .bearer_auth(&token)
            .send()
            .await
            .map_err(|e| ApiError::Network(e.to_string()))?;

        if !resp.status().is_success() {
            return Err(ApiError::Api(format!(
                "Delete failed: {}",
                resp.status()
            )));
        }

        Ok(())
    }

    pub async fn move_task(
        &self,
        list_id: &str,
        task_id: &str,
        prev: Option<&str>,
        sibling: Option<&str>,
    ) -> Result<(), ApiError> {
        let token = self.get_token().await?;

        let mut url = format!(
            "https://tasks.googleapis.com/tasks/v1/lists/{}/tasks/{}/move",
            list_id, task_id
        );

        if let Some(p) = prev {
            url.push_str(&format!("&previous={}", p));
        }
        if let Some(s) = sibling {
            url.push_str(&format!("&destinationTaskList={}", s));
        }

        let resp = self
            .client
            .post(&url)
            .bearer_auth(&token)
            .send()
            .await
            .map_err(|e| ApiError::Network(e.to_string()))?;

        if !resp.status().is_success() {
            return Err(ApiError::Api(format!("Move failed: {}", resp.status())));
        }

        Ok(())
    }
}