//! Request/response helpers shared by the JSON API and the classic HTML UI.

use crate::state::AppState;
use domain::models::import::DomainField;

pub(crate) fn build_export_response(
    format_str: &str,
    user_id: uuid::Uuid,
    state: &AppState,
) -> axum::response::Response {
    use axum::{body::Body, http::StatusCode, response::IntoResponse};
    use futures::StreamExt;

    use application::diary::{export_diary as export_diary_uc, queries::ExportQuery};
    use domain::models::ExportFormat;

    let format = match format_str {
        "csv" => ExportFormat::Csv,
        "json" => ExportFormat::Json,
        _ => return StatusCode::BAD_REQUEST.into_response(),
    };
    let (content_type, filename) = match &format {
        ExportFormat::Csv => ("text/csv; charset=utf-8", "diary.csv"),
        ExportFormat::Json => ("application/json", "diary.json"),
    };
    let query = ExportQuery { user_id, format };
    let stream = export_diary_uc::execute(&state.app_ctx.deps.diary.export_diary, query);
    let stream = stream.map(|r| {
        if let Err(ref e) = r {
            tracing::error!("diary export stream error: {e}");
        }
        r
    });
    (
        StatusCode::OK,
        [
            (axum::http::header::CONTENT_TYPE, content_type.to_string()),
            (
                axum::http::header::CONTENT_DISPOSITION,
                format!("attachment; filename=\"{}\"", filename),
            ),
        ],
        Body::from_stream(stream),
    )
        .into_response()
}

pub(crate) struct ProfileFormData {
    pub display_name: Option<String>,
    pub bio: Option<String>,
    pub avatar_bytes: Option<Vec<u8>>,
    pub avatar_content_type: Option<String>,
    pub banner_bytes: Option<Vec<u8>>,
    pub banner_content_type: Option<String>,
    pub also_known_as: Option<String>,
    pub profile_field_names: std::collections::HashMap<usize, String>,
    pub profile_field_values: std::collections::HashMap<usize, String>,
}

pub(crate) async fn parse_profile_multipart(
    mut multipart: axum::extract::Multipart,
) -> ProfileFormData {
    let mut data = ProfileFormData {
        display_name: None,
        bio: None,
        avatar_bytes: None,
        avatar_content_type: None,
        banner_bytes: None,
        banner_content_type: None,
        also_known_as: None,
        profile_field_names: std::collections::HashMap::new(),
        profile_field_values: std::collections::HashMap::new(),
    };

    while let Ok(Some(field)) = multipart.next_field().await {
        let name = field.name().unwrap_or("").to_string();
        match name.as_str() {
            "display_name" => {
                if let Ok(text) = field.text().await {
                    data.display_name = Some(text).filter(|s| !s.is_empty());
                }
            }
            "bio" => {
                if let Ok(text) = field.text().await {
                    data.bio = Some(text);
                }
            }
            "also_known_as" => {
                if let Ok(text) = field.text().await {
                    data.also_known_as = Some(text).filter(|s| !s.is_empty());
                }
            }
            "avatar" => {
                let ct = field.content_type().map(|s| s.to_string());
                if let Ok(bytes) = field.bytes().await
                    && !bytes.is_empty()
                {
                    data.avatar_bytes = Some(bytes.to_vec());
                    data.avatar_content_type = ct;
                }
            }
            "banner" => {
                let ct = field.content_type().map(|s| s.to_string());
                if let Ok(bytes) = field.bytes().await
                    && !bytes.is_empty()
                {
                    data.banner_bytes = Some(bytes.to_vec());
                    data.banner_content_type = ct;
                }
            }
            n if n.starts_with("field_name_") => {
                if let Ok(idx) = n["field_name_".len()..].parse::<usize>()
                    && let Ok(text) = field.text().await
                    && !text.is_empty()
                {
                    data.profile_field_names.insert(idx, text);
                }
            }
            n if n.starts_with("field_value_") => {
                if let Ok(idx) = n["field_value_".len()..].parse::<usize>()
                    && let Ok(text) = field.text().await
                    && !text.is_empty()
                {
                    data.profile_field_values.insert(idx, text);
                }
            }
            _ => {}
        }
    }

    data
}

pub(crate) fn str_to_domain_field(field: &str) -> Option<DomainField> {
    match field {
        "title" => Some(DomainField::Title),
        "release_year" => Some(DomainField::ReleaseYear),
        "director" => Some(DomainField::Director),
        "rating" => Some(DomainField::Rating),
        "watched_at" => Some(DomainField::WatchedAt),
        "comment" => Some(DomainField::Comment),
        "external_metadata_id" => Some(DomainField::ExternalMetadataId),
        _ => None,
    }
}