use ammonia::clean_text;
use axum::{Json, extract::{Path, State}, http::StatusCode, response::IntoResponse};
use serde::Deserialize;

use crate::{AppState, routes::{auth::AuthUser, errors::RouteError}};

#[derive(Deserialize)]
pub(crate) struct CreateSubmissionRequest {
    problem_id: i64,
    language: String,
    details: String,
    code: String,
}

pub async fn create_submission(
    State(state): State<AppState>,
    AuthUser(claims): AuthUser,
    Json(request): Json<CreateSubmissionRequest>
) -> Result<impl IntoResponse, RouteError> {
    let user_id = claims.sub;

    let code_length = request.code.len() as i64;
    
    let language = clean_text(&request.language);
    let details = clean_text(&request.details);
    let code = clean_text(&request.code);

    match state.database.insert_submission(
        user_id,
        request.problem_id,
        &language,
        &details,
        &code,
        code_length,
    ) {
        Ok(submission) => Ok((StatusCode::CREATED, Json(submission))),
        Err(e) => Err(RouteError::Internal(format!("unable to insert submission {e:?}")))
    }
}

pub async fn get_submissions_by_problem_id(
    State(state): State<AppState>,
    Path(problem_id): Path<i64>
) -> Result<impl IntoResponse, RouteError> {
    let submissions = state.database.fetch_submissions_by_problem_id(problem_id)
        .map_err(|_| RouteError::Internal("unable to fetch submissions".into()))?;
    Ok(Json(submissions))
}

pub async fn get_display_submissions(
    State(state): State<AppState>,
    Path(problem_id): Path<i64>
) -> Result<impl IntoResponse, RouteError> {
    let submissions = state.database.fetch_display_submissions(problem_id)
        .map_err(|e| RouteError::Internal(format!("unable to fetch submissions: {e:?}")))?;
    Ok(Json(submissions))
}

pub async fn get_display_submission(
    State(state): State<AppState>,
    Path(submission_id): Path<i64>
) -> Result<impl IntoResponse, RouteError> {
    match state.database.fetch_display_submission(submission_id) {
        Ok(None) => Err(RouteError::NotFound("submission".into())),
        Ok(Some(submission)) => Ok(Json(submission)),
        Err(e) => Err(RouteError::Internal(format!("unable to fetch submission: {e:?}")))
    }
}