use reqwest::Method;

use crate::api::job::models::{
    JobCreateRequest, JobCreateResponse, JobDispatchRequest, JobDispatchResponse, JobParseRequest,
};
use crate::models::job::Job;
use crate::{ClientError, NomadClient};

impl NomadClient {
    pub async fn job_dispatch(
        &self,
        job_name: &str,
        req: &JobDispatchRequest,
    ) -> Result<JobDispatchResponse, ClientError> {
        let req = self
            .request(Method::POST, &format!("/job/{}/dispatch", job_name))
            .json(req);

        self.send::<JobDispatchResponse>(req).await
    }

    pub async fn job_parse(&self, req: &JobParseRequest) -> Result<Job, ClientError> {
        let req = self.request(Method::POST, "/jobs/parse").json(req);

        self.send::<Job>(req).await
    }

    pub async fn job_create(
        &self,
        req: &JobCreateRequest,
    ) -> Result<JobCreateResponse, ClientError> {
        let req = self.request(Method::POST, "/jobs").json(req);

        self.send::<JobCreateResponse>(req).await
    }
}

pub mod models {
    use std::collections::HashMap;

    use crate::models::job::Job;
    use serde::{Deserialize, Serialize};

    #[derive(Debug, Default, Serialize)]
    #[serde(rename_all = "PascalCase")]
    pub struct JobDispatchRequest {
        pub payload: Option<String>,
        pub meta: Option<HashMap<String, String>>,
    }

    #[derive(Debug, Deserialize)]
    #[serde(rename_all = "PascalCase")]
    pub struct JobDispatchResponse {
        #[serde(alias = "DispatchedJobID")]
        pub dispatched_job_id: String,
        #[serde(alias = "EvalID")]
        pub eval_id: String,
        pub eval_crate_index: Option<u32>,
        pub job_crate_index: Option<u32>,
        pub index: u32,
    }

    #[derive(Debug, Default, Serialize)]
    #[serde(rename_all = "PascalCase")]
    pub struct JobParseRequest {
        #[serde(alias = "JobHCL")]
        pub job_hcl: String,
        pub canonicalize: Option<bool>,
        #[serde(alias = "HCLv1")]
        pub hcl_v1: Option<bool>,
    }

    #[derive(Debug, Default, Serialize)]
    #[serde(rename_all = "PascalCase")]
    pub struct JobCreateRequest {
        pub enforce_index: Option<bool>,
        pub eval_priority: Option<i32>,
        pub job: Option<Job>,
        pub job_modify_index: Option<i32>,
        pub namespace: Option<String>,
        pub policy_override: Option<bool>,
        pub preserve_counts: Option<bool>,
        pub region: Option<String>,
        #[serde(rename = "SecretID")]
        pub secret_id: Option<String>,
    }

    #[derive(Debug, Deserialize)]
    #[serde(rename_all = "PascalCase")]
    pub struct JobCreateResponse {
        pub eval_create_index: Option<i32>,
        #[serde(rename = "EvalID")]
        pub eval_id: Option<String>,
        pub job_modify_index: Option<i32>,
        pub known_leader: Option<bool>,
        pub last_contact: Option<i64>,
        pub last_index: Option<i32>,
        pub next_token: Option<String>,
        pub request_time: Option<i64>,
        pub warnings: Option<String>,
    }
}

#[cfg(test)]
mod tests {
    use crate::api::job::models::{
        JobCreateRequest, JobCreateResponse, JobDispatchRequest, JobParseRequest,
    };
    use crate::models::job::Job;
    use crate::{ClientError, NomadClient};

    static HCL_JOB_BATCH: &str = r#"
            job "exitWith" {
                type        = "batch"
                datacenters = ["dc1"]

                group "default" {
                    task "main" {
                        driver = "raw_exec"

                        config {
                            command = "sh"
                            args    = ["-c", "echo 'exit with 0' && exit 0"]
                        }
                    }
                }
            }
        "#;

    static HCL_JOB_BATCH_PARAM: &str = r#"
            job "exitWithParam" {
                type        = "batch"
                datacenters = ["dc1"]

                parameterized {
                  meta_required = []
                  meta_optional = []
                  payload       = "forbidden"
                }

                group "default" {
                    task "main" {
                        driver = "raw_exec"

                        config {
                            command = "sh"
                            args    = ["-c", "echo exit with 0 && exit 0"]
                        }
                    }
                }
            }
        "#;

    static HCL_JOB_BATCH_PARAM_REQUIRED: &str = r#"
            job "exitWithParamReq" {
                type        = "batch"
                datacenters = ["dc1"]

                parameterized {
                  meta_required = ["exitCode"]
                  meta_optional = []
                  payload       = "forbidden"
                }

                group "default" {
                    task "main" {
                        driver = "raw_exec"

                        config {
                            command = "sh"
                            args    = ["-c", "echo \"exit with ${NOMAD_META_exitCode}\" && exit ${NOMAD_META_exitCode}"]
                        }
                    }
                }
            }
        "#;

    #[tokio::test]
    async fn job_parse_should_return_valid_job() {
        let client = NomadClient::default();

        let body = JobParseRequest {
            job_hcl: HCL_JOB_BATCH.into(),
            ..JobParseRequest::default()
        };

        match client.job_parse(&body).await {
            Ok(job) => {
                assert_eq!(job.name, Some("exitWith".into()));
                assert_eq!(job.r#type, Some("batch".into()));
            }
            Err(e) => panic!("{:#?}", e),
        }
    }

    #[tokio::test]
    async fn job_create_should_create_job() {
        let client = NomadClient::default();

        match parse_and_setup_job(&client, HCL_JOB_BATCH).await {
            Ok((resp, job)) => assert!(resp.eval_id.is_some()),
            Err(e) => panic!("{:#?}", e),
        }
    }

    #[tokio::test]
    async fn job_dispatch_should_dispatch_existing_job() {
        let client = NomadClient::default();

        match parse_and_setup_job(&client, HCL_JOB_BATCH_PARAM).await {
            Ok((_, job)) => {
                match client
                    .job_dispatch(job.name.unwrap().as_str(), &JobDispatchRequest::default())
                    .await
                {
                    Ok(_) => assert!(true),
                    Err(e) => panic!("{:#?}", e),
                };
            }
            Err(e) => panic!("{:#?}", e),
        }
    }

    async fn parse_and_setup_job(
        client: &NomadClient,
        hcl: &str,
    ) -> Result<(JobCreateResponse, Job), ClientError> {
        let parse_req = JobParseRequest {
            job_hcl: hcl.into(),
            ..JobParseRequest::default()
        };

        return match client.job_parse(&parse_req).await {
            Ok(job) => {
                let req = JobCreateRequest {
                    job: Some(job.clone()),
                    ..JobCreateRequest::default()
                };

                match client.job_create(&req).await {
                    Ok(response) => Ok((response, job)),
                    Err(e) => Err(e),
                }
            }
            Err(e) => Err(e),
        };
    }

    // let body = JobCreateRequest{
    //     job: Some(Job{
    //         id: Some("exitWithRaw2".into()),
    //         r#type: Some("batch".into()),
    //         datacenters: Some(vec!["dc1".into()]),
    //         task_groups: Some(vec![
    //             TaskGroup {
    //                 name: Some("default".into()),
    //                 tasks: Some(vec![
    //                     Task{
    //                         name: Some("main".into()),
    //                         driver: Some("raw_exec".into()),
    //                         config: Some(config),
    //                         ..Task::default()
    //                     }
    //                 ]),
    //                 ..TaskGroup::default()
    //             }
    //         ]),
    //         ..Job::default()
    //     }),
    //     ..JobCreateRequest::default()
    // };
}