use chrono::NaiveDate;
use pipeline_application::application::{
    Application, Env, InlineInspection, InspectionType, ReportType, ToolTolerances,
};
use serde::{Deserialize, Deserializer};
use uuid::Uuid;

// There is an issue with the data form component at the moment and its giving back
// a null value
const DEFAULT_PROJECT_ID: &str = "680b61b0aedd6f9e639d8699";

#[fathom_function::function]
async fn pipeline_route(input: Input) -> Result<String, String> {
    let reports_details = input.report_details;
    let app = Application::new(
        Env::Dev,
        input.org_id,
        input.project_id.as_deref().unwrap_or(DEFAULT_PROJECT_ID),
    )
    .unwrap();

    for (pipeline_id, file_details) in input.pipeline_id.into_iter().zip(input.file_details) {
        app.process_ili_report(
            pipeline_id,
            file_details.file_id,
            ToolTolerances::default(),
            &reports_details,
        )
        .await
        .unwrap();
    }
    Ok("Success".to_owned())
}

#[derive(Debug, Deserialize)]
struct Input {
    org_id: Uuid,
    project_id: Option<String>,
    pipeline_id: Vec<Uuid>,
    file_details: Vec<FileDetails>,
    // TODO: parse the output of the tool tolerances.
    #[serde(flatten)]
    report_details: InspectionReportDetails,
}

#[derive(Debug, Deserialize)]
struct InspectionReportDetails {
    #[serde(deserialize_with = "deserialize_date")]
    date: NaiveDate,
    vendor_name: String,
    report_type: ReportType,
    /// The inspection type and technology used.
    inspection_type: InspectionType,
}

impl From<&InspectionReportDetails> for InlineInspection {
    fn from(value: &InspectionReportDetails) -> Self {
        Self {
            date: value.date,
            vendor_name: value.vendor_name.to_owned(),
            report_type: value.report_type,
            inspection_type: value.inspection_type,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileDetails {
    pub file_id: Uuid,
    pub revision_id: Uuid,
}

const FORMAT: &'static str = "%a %b %d %Y";

pub fn deserialize_date<'de, D>(deserializer: D) -> Result<NaiveDate, D::Error>
where
    D: Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;
    let dt = NaiveDate::parse_from_str(&s, FORMAT).map_err(serde::de::Error::custom)?;
    Ok(dt)
}