use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use sqlx::{FromRow, PgPool};
use uuid::Uuid;

#[derive(Debug, Serialize, Deserialize, FromRow)]
pub struct LeadRequest {
    pub id: Uuid,
    pub requirement_id: Uuid,
    pub professional_id: Uuid,
    pub status: String, // PENDING, ACCEPTED, REJECTED, EXPIRED, CANCELLED
    pub tracecoins_reserved: i32,
    pub expires_at: DateTime<Utc>,
    pub requested_at: DateTime<Utc>,
    pub resolved_at: Option<DateTime<Utc>>,
    pub professional_user_id: Option<Uuid>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateLeadRequestPayload {
    pub requirement_id: Uuid,
    pub professional_id: Uuid,
    pub expires_at: DateTime<Utc>,
}

pub struct LeadRequestRepository;

impl LeadRequestRepository {
    pub async fn create(
        pool: &PgPool,
        payload: CreateLeadRequestPayload,
    ) -> Result<LeadRequest, sqlx::Error> {
        let req = sqlx::query_as!(
            LeadRequest,
            r#"
            INSERT INTO lead_requests (requirement_id, professional_id, expires_at)
            VALUES ($1, $2, $3)
            RETURNING *
            "#,
            payload.requirement_id,
            payload.professional_id,
            payload.expires_at
        )
        .fetch_one(pool)
        .await?;

        Ok(req)
    }

    pub async fn get_by_id(pool: &PgPool, id: Uuid) -> Result<Option<LeadRequest>, sqlx::Error> {
        sqlx::query_as!(LeadRequest, "SELECT * FROM lead_requests WHERE id = $1", id)
            .fetch_optional(pool)
            .await
    }

    pub async fn list_by_requirement_id(
        pool: &PgPool,
        requirement_id: Uuid,
        page: i64,
        limit: i64,
    ) -> Result<Vec<LeadRequest>, sqlx::Error> {
        let offset = (page - 1) * limit;
        let reqs = sqlx::query_as!(
            LeadRequest,
            r#"
            SELECT * FROM lead_requests 
            WHERE requirement_id = $1
            ORDER BY requested_at DESC
            LIMIT $2 OFFSET $3
            "#,
            requirement_id,
            limit,
            offset
        )
        .fetch_all(pool)
        .await?;

        Ok(reqs)
    }

    pub async fn update_status(
        pool: &PgPool,
        id: Uuid,
        status: &str,
    ) -> Result<LeadRequest, sqlx::Error> {
        let req = sqlx::query_as!(
            LeadRequest,
            r#"
            UPDATE lead_requests 
            SET status = $1, resolved_at = NOW(), updated_at = NOW() 
            WHERE id = $2 
            RETURNING *
            "#,
            status,
            id
        )
        .fetch_one(pool)
        .await?;
        Ok(req)
    }
}