// src/protocol/message.rs

use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentMessage {
    pub id: String,        // 메시지 고유 ID
    pub sender: String,    // 발신 에이전트 ID
    pub target: String,    // 수신 에이전트 ID
    pub timestamp: i64,    // 타임스탬프
    pub payload: Payload,  // 실제 데이터
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum Payload {
    #[serde(rename = "task/request")]
    TaskRequest {
        task_id: Uuid,
        description: String,
        context: serde_json::Value,
    },
    
    #[serde(rename = "task/result")]
    TaskResult {
        task_id: Uuid,
        status: TaskStatus,
        data: Option<serde_json::Value>,
    },
    
    #[serde(rename = "system/ping")]
    SystemPing,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TaskStatus {
    Success,
    Failure(String), // 실패 사유
    Pending,
}

// src/runtime/agent.rs

use tokio::sync::mpsc;
use crate::protocol::message::{AgentMessage, Payload};

pub struct Agent {
    id: String,
    tx: mpsc::Sender<AgentMessage>, // 외부로 메시지를 보내는 송신자
    rx: mpsc::Receiver<AgentMessage>, // 내부에서 메시지를 받는 수신자
}

impl Agent {
    pub fn new(id: String) -> Self {
        let (tx, rx) = mpsc::channel(100);
        Self { id, tx, rx }
    }

    // 에이전트의 메인 실행 루프
    pub async fn run(mut self) {
        println!("[{}] Agent started", self.id);
        while let Some(msg) = self.rx.recv().await {
            if let Err(e) = self.handle_message(msg).await {
                eprintln!("[{}] Error handling message: {:?}", self.id, e);
            }
        }
    }

    async fn handle_message(&self, msg: AgentMessage) -> Result<(), Box<dyn std::error::Error>> {
        match msg.payload {
            Payload::SystemPing => {
                // 핑에 퐁으로 응답하는 로직
                // 실제 환경에서는 클라이언트의 tx를 사용해 응답을 보냄
                println!("[{}] Received Ping from {}", self.id, msg.sender);
            }
            Payload::TaskRequest { task_id, description, context } => {
                println!("[{}] Received Task {}: {}", self.id, task_id, description);
                // 여기에 LLM 호출이나 도구 실행 로직이 들어갑니다.
                
                // 예: 결과 반환 로직 (가상)
                // self.send_result(task_id, ...).await;
            }
            _ => {
                println!("[{}] Received unhandled message type", self.id);
            }
        }
        Ok(())
    }
}