orign 0.2.3

use crate::auth::agent::get_orign_agent_key;
use crate::humans::slack::client::ask_chat_approval;
use crate::mutation::Mutation;
use crate::query::Query;
use crate::{
    models::V1UserProfile,
    resources::v1::humans::models::{
        V1FeedbackRequest, V1FeedbackRequestKind, V1FeedbackResponse, V1Human, V1HumanRequest,
        V1HumanStatus, V1Humans,
    },
    state::AppState,
};
use anyhow::Result;
use axum::{
    extract::{Extension, Path, State},
    http::StatusCode,
    response::IntoResponse,
    Json,
};
use chrono::Utc;
use nebulous::client::NebulousClient;
use nebulous::models::V1ResourceMeta;
use nebulous::resources::v1::containers::models::{V1ContainerRequest, V1EnvVar};
use sea_orm::ActiveModelTrait;
use sea_orm::ActiveValue::{NotSet, Set, Unchanged};
use sea_orm::DatabaseConnection;
use sea_orm::IntoActiveModel;
use serde_json::json;
use short_uuid::ShortUuid;
use tracing::{debug, info};

pub async fn create_human(
    State(state): State<AppState>,
    Extension(user_profile): Extension<V1UserProfile>,
    Json(payload): Json<V1HumanRequest>,
) -> impl IntoResponse {
    info!("Creating human resource: {:?}", payload);

    let db = state.db_pool.clone();
    let id = ShortUuid::generate().to_string();

    // 1) Prepare a list of valid owner IDs: user's email and all associated orgs
    let mut owner_ids: Vec<String> = if let Some(orgs) = &user_profile.organizations {
        orgs.keys().cloned().collect()
    } else {
        Vec::new()
    };
    owner_ids.push(user_profile.email.clone());

    // 2) Determine the owner (fallback to user's email if none provided)
    let owner = if payload.metadata.owner.is_empty() {
        user_profile.email.clone()
    } else {
        payload.metadata.owner.clone()
    };

    // 3) Ensure the owner is one of the valid IDs
    if !owner_ids.contains(&owner) {
        return (
            StatusCode::FORBIDDEN,
            Json(json!({ "error": "Unauthorized owner specified" })),
        );
    }

    let now = Utc::now();

    // 4) Prepare a new ActiveModel record. Adjust fields to match your entity schema.
    let new_human = crate::entities::human::ActiveModel {
        id: sea_orm::Set(id.clone()),
        name: sea_orm::Set(payload.metadata.name.clone()),
        namespace: sea_orm::Set(payload.metadata.namespace.clone()),
        owner_id: sea_orm::Set(owner),
        medium: sea_orm::Set(payload.medium.clone()),
        channel: sea_orm::Set(payload.channel.clone()),
        response_job: sea_orm::Set(Some(
            serde_json::to_value(payload.response_job.clone()).unwrap(),
        )),
        status: sea_orm::Set(None),
        created_at: sea_orm::Set(now.into()),
        updated_at: sea_orm::Set(now.into()),
        created_by: sea_orm::Set(user_profile.email.clone()),
        labels: sea_orm::Set(payload.metadata.labels.map(|map| serde_json::json!(map))),
        ..Default::default()
    };

    // 5) Insert the new record
    let inserted_human: crate::entities::human::Model = match new_human.insert(&db).await {
        Ok(model) => model,
        Err(err) => {
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(json!({ "error": format!("Failed to insert Human: {}", err) })),
            );
        }
    };

    debug!("Inserted new Human with id {:?}", inserted_human.id);

    // 6) Construct a response that parallels your LLM response
    let response = V1Human {
        metadata: nebulous::models::V1ResourceMeta {
            id: inserted_human.id,
            name: inserted_human.name,
            namespace: inserted_human.namespace,
            owner: inserted_human.owner_id,
            created_at: inserted_human.created_at.timestamp(),
            updated_at: inserted_human.updated_at.timestamp(),
            created_by: inserted_human.created_by,
            labels: inserted_human
                .labels
                .map(|json_value| serde_json::from_value(json_value).unwrap_or_default()),
            owner_ref: None, // Example: If you store an owner_ref, fill that here
        },
        medium: inserted_human.medium,
        channel: inserted_human.channel,
        response_job: payload.response_job,
        status: V1HumanStatus {
            is_active: None,
            last_active: None,
        },
    };

    (StatusCode::CREATED, Json(json!(response)))
}

pub async fn list_humans(
    State(state): State<AppState>,
    Extension(user_profile): Extension<V1UserProfile>,
) -> impl IntoResponse {
    let db = state.db_pool.clone();
    info!("Listing humans for user: {}", user_profile.email);

    // 1) Gather the possible owner IDs (user + orgs)
    let mut owner_ids: Vec<String> = if let Some(orgs) = &user_profile.organizations {
        orgs.keys().cloned().collect()
    } else {
        Vec::new()
    };
    owner_ids.push(user_profile.email.clone());
    let owner_id_refs: Vec<&str> = owner_ids.iter().map(|s| s.as_str()).collect();

    // 2) Query all human rows whose owner is in the allowed set
    let human_models = match Query::find_humans_by_owners(&db, &owner_id_refs).await {
        Ok(models) => models,
        Err(err) => {
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(json!({ "error": format!("Failed to query humans: {}", err) })),
            )
                .into_response();
        }
    };

    // 3) Convert each DB model into a V1Human
    let mut humans_list = Vec::new();
    for human_model in human_models {
        // a) Construct the metadata
        let metadata = V1ResourceMeta {
            id: human_model.id.clone(),
            name: human_model.name.clone(),
            namespace: human_model.namespace.clone(),
            owner: human_model.owner_id.clone(),
            created_at: human_model.created_at.timestamp(),
            updated_at: human_model.updated_at.timestamp(),
            created_by: human_model.created_by,
            labels: human_model.labels.map(|json_value| {
                serde_json::from_value::<std::collections::HashMap<String, String>>(json_value)
                    .unwrap_or_default()
            }),
            owner_ref: None,
        };

        // b) Construct the status
        let status = V1HumanStatus {
            is_active: None,
            last_active: None,
        };

        // c) Push into the results array
        humans_list.push(V1Human {
            metadata,
            medium: human_model.medium,
            channel: human_model.channel,
            response_job: serde_json::from_value(human_model.response_job.unwrap_or_default())
                .unwrap_or_default(),
            status,
        });
    }

    // 4) Return as JSON wrapped in V1Humans
    let response = V1Humans {
        humans: humans_list,
    };
    (StatusCode::OK, Json(response)).into_response()
}

pub async fn get_human(
    Path((namespace, name)): Path<(String, String)>,
    State(state): State<AppState>,
    Extension(user_profile): Extension<V1UserProfile>,
) -> impl IntoResponse {
    // 1) Build a list of allowed owner IDs (user + orgs)
    let mut owner_ids: Vec<String> = if let Some(orgs) = &user_profile.organizations {
        orgs.keys().cloned().collect()
    } else {
        Vec::new()
    };
    owner_ids.push(user_profile.email.clone());
    let owner_id_refs: Vec<&str> = owner_ids.iter().map(|s| s.as_str()).collect();

    info!(
        "Fetching human with namespace={} and name={}",
        namespace, name
    );

    // 2) Query the `human` table for a record matching name + namespace + owners
    match Query::find_human_by_name_and_namespace_and_owners(
        &state.db_pool,
        &name,
        &namespace,
        &owner_id_refs,
    )
    .await
    {
        // 3a) If found, convert to our V1Human representation
        Ok(Some(human_model)) => {
            let response = V1Human {
                metadata: V1ResourceMeta {
                    id: human_model.id,
                    name: human_model.name,
                    namespace: human_model.namespace,
                    owner: human_model.owner_id,
                    created_at: human_model.created_at.timestamp(),
                    updated_at: human_model.updated_at.timestamp(),
                    created_by: human_model.created_by,
                    labels: human_model
                        .labels
                        .map(|json_value| serde_json::from_value(json_value).unwrap_or_default()),
                    owner_ref: None,
                },
                medium: human_model.medium,
                channel: human_model.channel,
                response_job: serde_json::from_value(human_model.response_job.unwrap_or_default())
                    .unwrap_or_default(),
                status: V1HumanStatus {
                    is_active: None,
                    last_active: None,
                },
            };

            (StatusCode::OK, Json(response)).into_response()
        }
        // 3b) If no match, return 404
        Ok(None) => (
            StatusCode::NOT_FOUND,
            Json(json!({ "error": "Human not found" })),
        )
            .into_response(),
        // 3c) Handle any database errors
        Err(err) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(json!({ "error": format!("DB error: {}", err) })),
        )
            .into_response(),
    }
}

pub async fn delete_human(
    Path((namespace, name)): Path<(String, String)>,
    State(state): State<AppState>,
    Extension(user_profile): Extension<crate::models::V1UserProfile>,
) -> impl IntoResponse {
    // 1) Gather allowed owner IDs: the user's email + any orgs.
    let mut owner_ids: Vec<String> = user_profile
        .organizations
        .as_ref()
        .map(|orgs| orgs.keys().cloned().collect())
        .unwrap_or_default();
    owner_ids.push(user_profile.email.clone());
    let owner_id_refs: Vec<&str> = owner_ids.iter().map(String::as_str).collect();

    // 2) Attempt the deletion
    match Mutation::delete_human_by_name_namespace_and_owners(
        &state.db_pool,
        &name,
        &namespace,
        &owner_id_refs,
    )
    .await
    {
        Ok(0) => {
            // If 0 rows were deleted, it's effectively "not found"
            (
                StatusCode::NOT_FOUND,
                Json(json!({"error": "Human not found"})),
            )
                .into_response()
        }
        Ok(_) => {
            // Return 204 (No Content) on success
            StatusCode::NO_CONTENT.into_response()
        }
        Err(err) => {
            // Database or query error
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(json!({"error": format!("DB error: {}", err)})),
            )
                .into_response()
        }
    }
}

pub async fn request_human_feedback(
    Path((namespace, name)): Path<(String, String)>,
    State(state): State<AppState>,
    Extension(user_profile): Extension<V1UserProfile>,
    Json(feedback_request): Json<V1FeedbackRequest>,
) -> impl IntoResponse {
    let db = state.db_pool.clone();

    // 1) Gather allowed owner IDs
    let mut owner_ids: Vec<String> = user_profile
        .organizations
        .as_ref()
        .map(|orgs| orgs.keys().cloned().collect())
        .unwrap_or_default();
    owner_ids.push(user_profile.email.clone());
    let owner_id_refs: Vec<&str> = owner_ids.iter().map(String::as_str).collect();

    let feedback_id = ShortUuid::generate().to_string();

    // 1) Fetch the Option<Human> from DB, returning 500 on error
    let model_opt = match crate::query::Query::find_human_by_name_and_namespace_and_owners(
        &state.db_pool,
        &name,
        &namespace,
        &owner_id_refs,
    )
    .await
    {
        Ok(val) => val,
        Err(err) => {
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(json!({"error": format!("DB error fetching Human: {}", err)})),
            )
                .into_response();
        }
    };

    // 2) Use let-else to handle the None case with a 404 response
    let Some(human_model) = model_opt else {
        return (
            StatusCode::NOT_FOUND,
            Json(json!({"error": "Human not found"})),
        )
            .into_response();
    };

    let resource_ref = format!("{}.{}.Human", name, namespace);

    // 4) Insert a new feedback row in the database *before* making the Slack request
    let new_feedback = crate::entities::feedback::ActiveModel {
        id: sea_orm::Set(feedback_id.to_string()),
        owner_id: sea_orm::Set(human_model.owner_id.clone()),
        human_id: sea_orm::Set(human_model.id.clone()),
        kind: sea_orm::Set(feedback_request.kind.clone()),
        request: sea_orm::Set(
            serde_json::to_value(&feedback_request).unwrap_or_else(|_| json!(null)),
        ),
        response: sea_orm::Set(None),
        status: sea_orm::Set(None),
        created_by: sea_orm::Set(user_profile.email.clone()),
        created_at: sea_orm::Set(chrono::Utc::now().into()),
        updated_at: sea_orm::Set(chrono::Utc::now().into()),
    };

    // Perform the insert
    if let Err(err) = new_feedback.insert(&db).await {
        return (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(json!({"error": format!("Failed to insert feedback record: {}", err)})),
        )
            .into_response();
    }

    // 3) Branch on the Human's medium
    match human_model.medium.to_lowercase().as_str() {
        "slack" => {
            // If Slack, delegate to a dedicated function
            match request_slack_feedback(
                &feedback_id,
                &human_model,
                feedback_request,
                &human_model.owner_id,
                &resource_ref,
            )
            .await
            {
                Ok(()) => StatusCode::OK.into_response(), // Return 200 only
                Err((status, err_json)) => (status, err_json).into_response(),
            }
        }
        // If not Slack, handle or return an error
        _ => (
            StatusCode::BAD_REQUEST,
            Json(json!({"error": "Currently, only Slack is supported."})),
        )
            .into_response(),
    }
}

async fn request_slack_feedback(
    feedback_id: &str,
    human_model: &crate::entities::human::Model,
    feedback_request: V1FeedbackRequest,
    owner: &str,
    resource_ref: &str,
) -> Result<(), (StatusCode, Json<serde_json::Value>)> {
    // 1) Ensure the Slack channel is present
    let Some(ref slack_channel) = human_model.channel else {
        return Err((
            StatusCode::BAD_REQUEST,
            Json(json!({ "error": "Slack channel not specified" })),
        ));
    };

    // 2) Check that the kind is actually "approval"
    if feedback_request.kind.to_lowercase() != "approval" {
        return Err((
            StatusCode::BAD_REQUEST,
            Json(json!({ "error": "Unsupported feedback request kind" })),
        ));
    }

    // 3) Extract the V1ApprovalRequest from the feedback_request
    let Some(request_kind) = feedback_request.request else {
        return Err((
            StatusCode::BAD_REQUEST,
            Json(json!({"error": "No request data found in feedback request"})),
        ));
    };

    // 4) Match on the V1FeedbackRequestKind to pull out the approval data
    #[allow(irrefutable_let_patterns)]
    let V1FeedbackRequestKind::V1ApprovalRequest(approval_data) = request_kind
    else {
        return Err((
            StatusCode::BAD_REQUEST,
            Json(json!({"error": "Request kind did not contain V1ApprovalRequest"})),
        ));
    };

    let content = approval_data.content;
    let messages = match approval_data.messages {
        Some(messages) => messages,
        None => {
            return Err((
                StatusCode::BAD_REQUEST,
                Json(json!({"error": "Messages field is required but was not provided"})),
            ))
        }
    };

    debug!("Asking for approval of messages: {:?}", messages);

    // 4) Depending on the media_type, choose the Slack question function
    let result = match ask_chat_approval(
        slack_channel,
        &messages,
        &content,
        feedback_id,
        resource_ref,
        owner,
    )
    .await
    {
        Ok(_) => Ok(()),
        Err(err) => Err((
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(json!({"error": format!("Slack post failed: {}", err)})),
        )),
    };

    // 5) Post to Slack
    match result {
        Ok(_) => Ok(()), // On success, return nothing but an OK
        Err((status, json_err)) => Err((status, json_err)),
    }
}

// List human feedback
pub async fn list_human_feedback(
    Path((namespace, name)): Path<(String, String)>,
    State(state): State<AppState>,
    Extension(user_profile): Extension<V1UserProfile>,
) -> impl IntoResponse {
    todo!()
}

// Record human response
pub async fn record_human_response(
    Path((namespace, name, id)): Path<(String, String, String)>,
    State(state): State<AppState>,
    Extension(user_profile): Extension<V1UserProfile>,
    Json(feedback_response): Json<V1FeedbackResponse>,
) -> impl IntoResponse {
    debug!(
        "Recording human response for feedback: {:?}",
        feedback_response
    );
    // 1) Gather allowed owners (the user's email + any orgs).
    let mut owner_ids: Vec<String> = if let Some(orgs) = &user_profile.organizations {
        orgs.keys().cloned().collect()
    } else {
        Vec::new()
    };
    owner_ids.push(user_profile.email.clone());

    debug!("Getting orign agent key");
    let orign_agent_key = match get_orign_agent_key(&user_profile).await {
        Ok(key) => key,
        Err(e) => {
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(json!({ "error": format!("Failed to get orign agent key: {}", e) })),
            ));
        }
    };
    debug!("Orign agent key: {}", orign_agent_key);

    // Call the internal function and convert its result to an HTTP response
    match process_human_response(
        &state.db_pool,
        &owner_ids,
        &orign_agent_key,
        &namespace,
        &name,
        &id,
        feedback_response,
    )
    .await
    {
        Ok(_) => Ok(StatusCode::OK.into_response()),
        Err((status, json)) => Err((status, json)),
    }
}

// Internal function that contains the core logic and can be called from other contexts
pub async fn process_human_response(
    db: &DatabaseConnection,
    owner_ids: &Vec<String>,
    agent_key: &str,
    namespace: &str,
    name: &str,
    id: &str,
    feedback_response: V1FeedbackResponse,
) -> Result<(), (StatusCode, Json<serde_json::Value>)> {
    let owner_id_refs: Vec<&str> = owner_ids.iter().map(String::as_str).collect();

    // 2) Find the Human by namespace, name, and allowed owners.
    let human_opt = match Query::find_human_by_name_and_namespace_and_owners(
        &db,
        name,
        namespace,
        &owner_id_refs,
    )
    .await
    {
        Ok(h) => h,
        Err(err) => {
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(json!({ "error": format!("DB error fetching Human: {}", err) })),
            ));
        }
    };

    // 2b) If no Human found, return 404.
    let Some(human_model) = human_opt else {
        return Err((
            StatusCode::NOT_FOUND,
            Json(json!({ "error": "Human not found" })),
        ));
    };

    // 3) Find the Feedback record by ID and ensure it matches the found Human.
    let feedback_opt = match Query::find_feedback_by_id_and_human_id(&db, id, &human_model.id).await
    {
        Ok(fb) => fb,
        Err(err) => {
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(json!({ "error": format!("DB error fetching Feedback: {}", err) })),
            ));
        }
    };

    let Some(feedback_model) = feedback_opt else {
        return Err((
            StatusCode::NOT_FOUND,
            Json(json!({ "error": "Feedback not found" })),
        ));
    };

    debug!("Feedback model: {:?}", feedback_model);
    let response_value = serde_json::to_value(&feedback_response).unwrap_or_else(|_| json!(null));

    // 4) Update the feedback record with the new response data and current time.
    let mut feedback_active_model = feedback_model.into_active_model();
    feedback_active_model.response = Set(Some(response_value.clone()));
    feedback_active_model.updated_at = Set(Utc::now().into());

    // Grab the ID before updating, too
    let feedback_id = feedback_active_model.id.clone();

    // 5) Persist the updated record to DB.
    if let Err(err) = feedback_active_model.update(db).await {
        return Err((
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(json!({ "error": format!("Failed to update Feedback: {}", err) })),
        ));
    }
    debug!("Feedback updated");

    // Now reuse the info you extracted in local variables (feedback_id, response_value).
    let feedback_value_str = response_value.to_string();
    debug!("feedback_value_str: {}", feedback_value_str);

    // Kick off the container
    debug!("Kicking off container");
    let nebulous_client = match NebulousClient::new_from_config() {
        Ok(client) => client,
        Err(e) => {
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(json!({ "error": format!("Failed to create nebulous client: {}", e) })),
            ));
        }
    };

    let mut container_request: V1ContainerRequest =
        serde_json::from_value(human_model.response_job.unwrap_or_default()).unwrap_or_default();

    let mut container_env = match container_request.env {
        Some(env) => env,
        None => Vec::new(),
    };

    // Extract the ID as a plain String
    let feedback_id_str = match feedback_id.clone() {
        Set(v) | Unchanged(v) => v,
        NotSet => String::new(),
    };

    container_env.push(V1EnvVar {
        key: "FEEDBACK_ID".to_string(),
        value: Some(feedback_id_str),
        secret_name: None,
    });

    container_env.push(V1EnvVar {
        key: "FEEDBACK_RESPONSE".to_string(),
        value: Some(feedback_value_str),
        secret_name: None,
    });

    container_env.push(V1EnvVar {
        key: "ORIGN_API_KEY".to_string(),
        value: Some(agent_key.to_string()),
        secret_name: None,
    });

    container_request.env = Some(container_env);

    let container = match nebulous_client.create_container(&container_request).await {
        Ok(c) => c,
        Err(e) => {
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(json!({ "error": format!("Failed to create container: {}", e) })),
            ));
        }
    };

    debug!("Container created: {:?}", container);

    // Return Ok on success
    Ok(())
}

// Get human feedback
pub async fn get_human_feedback(
    Path((namespace, name, id)): Path<(String, String, String)>,
    State(state): State<AppState>,
) -> impl IntoResponse {
    todo!()
}