use std::collections::HashMap;

use anyhow::{anyhow, Result};
use serde::{Deserialize, Serialize};

use crate::{helpers::Connection, metric::Metric, metric::Metrics, Formalize};

#[derive(PartialEq, Eq, Debug, Serialize, Deserialize, Clone)]
pub struct MinScore {
    pub absolute: Option<u32>,
    pub percentage: Option<u32>,
}

#[derive(PartialEq, Eq, Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum HelperScore {
    MinScore(MinScore),
    ShortMinScore(u32),
}

impl From<HelperScore> for MinScore {
    fn from(helper_source: HelperScore) -> Self {
        match helper_source {
            HelperScore::MinScore(score) => score,
            HelperScore::ShortMinScore(source) => MinScore {
                percentage: Some(source),
                absolute: None,
            },
        }
    }
}

#[derive(PartialEq, Eq, Debug, Serialize, Deserialize, Clone)]
pub struct Evaluation {
    #[serde(default, alias = "Name", alias = "NAME")]
    pub name: Option<String>,
    #[serde(alias = "Description", alias = "DESCRIPTION")]
    pub description: Option<String>,
    #[serde(alias = "Metrics", alias = "METRICS")]
    pub metrics: Vec<String>,
    #[serde(
        default,
        rename = "min-score",
        alias = "Min-score",
        alias = "MIN-SCORE",
        skip_serializing
    )]
    pub _helper_min_score: Option<HelperScore>,
    #[serde(default, skip_deserializing)]
    pub min_score: Option<MinScore>,
}

impl Evaluation {
    pub fn validate_evaluation_metric_scores(
        &self,
        potential_metrics: Option<&Metrics>,
    ) -> Result<()> {
        if let Some(metrics) = potential_metrics {
            let metric_score_sum = metrics.iter().map(|s| s.1.max_score).sum();
            if let Some(min_score) = &self.min_score {
                if let Some(absolute_min_score) = min_score.absolute {
                    if absolute_min_score > metric_score_sum {
                        return Err(anyhow!(
                            "Sum of metric scores has to be smaller than the evaluation min-score"
                        ));
                    }
                }
            }
        } else {
            return Err(anyhow!(
                "Evaluation requires Metrics but none found under Scenario",
            ));
        }
        Ok(())
    }
}

impl Connection<Metric> for (&String, &Evaluation) {
    fn validate_connections(&self, potential_metric_names: &Option<Vec<String>>) -> Result<()> {
        if let Some(metric_names) = potential_metric_names {
            for metric_name in &self.1.metrics {
                if !metric_names.contains(metric_name) {
                    return Err(anyhow::anyhow!(
                        "Evaluation \"{evaluation_name}\" Metric \"{metric_name}\" not found under Scenario Metrics",
                        evaluation_name = self.0
                    ));
                }
            }
        } else {
            return Err(anyhow::anyhow!(
                "Evaluation \"{evaluation_name}\" requires Metrics but none found under Scenario",
                evaluation_name = self.0
            ));
        }
        Ok(())
    }
}

pub type Evaluations = HashMap<String, Evaluation>;

impl Formalize for Evaluation {
    fn formalize(&mut self) -> Result<()> {
        if let Some(helper_min_score) = &self._helper_min_score {
            self.min_score = Some(helper_min_score.to_owned().into());
        } else {
            return Err(anyhow!("An Evaluation is missing min-score"));
        }
        if let Some(score) = &self.min_score {
            if score.absolute.is_some() && score.percentage.is_some() {
                return Err(anyhow!(
                    "An Evaluations min-score can only have either Absolute or Percentage defined, not both"
                ));
            }
        }
        if self.metrics.is_empty() {
            return Err(anyhow!("An Evaluation must have at least one Metric"));
        }
        if let Some(min_score) = &self.min_score {
            if let Some(percentage) = min_score.percentage {
                if percentage > 100 {
                    return Err(anyhow!("Min score percentage can not be over 100%"));
                }
            }
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parse_sdl;

    #[test]
    fn parses_sdl_with_evaluation() {
        let sdl = r#"
            name: test-scenario
            description: some description
            start: 2022-01-20T13:00:00Z
            end: 2022-01-20T23:00:00Z
            conditions:
                condition-1:
                    command: executable/path.sh
                    interval: 30
            metrics:
                metric-1:
                    type: MANUAL
                    artifact: true
                    max-score: 10
                metric-2:
                    type: CONDITIONAL
                    max-score: 10
                    condition: condition-1
            evaluations:
                evaluation-1:
                    description: some description
                    metrics:
                        - metric-1
                        - metric-2
                    min-score: 50
        "#;
        let evaluations = parse_sdl(sdl).unwrap().evaluations;
        insta::with_settings!({sort_maps => true}, {
                insta::assert_yaml_snapshot!(evaluations);
        });
    }

    #[test]
    #[should_panic(
        expected = "Evaluation \"evaluation-1\" Metric \"metric-2\" not found under Scenario Metrics"
    )]
    fn fails_with_missing_metric() {
        let sdl = r#"
            name: test-scenario
            description: some description
            conditions:
                condition-1:
                    command: executable/path.sh
                    interval: 30
            metrics:
                metric-1:
                    type: MANUAL
                    artifact: true
                    max-score: 10
            evaluations:
                evaluation-1:
                    description: some description
                    metrics:
                        - metric-1
                        - metric-2
                    min-score: 50
        "#;
        parse_sdl(sdl).unwrap();
    }

    #[test]
    fn parses_shorthand_evaluation() {
        let evaluation_string = r#"
          description: some-description
          metrics:
            - metric-1
            - metric-2
          min-score: 50
        "#;
        let mut evaluation: Evaluation = serde_yaml::from_str(evaluation_string).unwrap();
        assert!(evaluation.formalize().is_ok());
    }

    #[test]
    fn parses_longhand_evaluation() {
        let evaluation_string = r#"
        description: some-description
        metrics:
          - metric-1
          - metric-2
        min-score:
          absolute: 50
      "#;
        let mut evaluation: Evaluation = serde_yaml::from_str(evaluation_string).unwrap();
        assert!(evaluation.formalize().is_ok());
    }

    #[test]
    fn fails_to_parse_evaluation_with_both_scores() {
        let evaluation_string = r#"
          description: some-description
          metrics:
            - metric-1
            - metric-2
          min-score:
            absolute: 50
            percentage: 60
        "#;
        let mut evaluation: Evaluation = serde_yaml::from_str(evaluation_string).unwrap();
        assert!(evaluation.formalize().is_err());
    }

    #[test]
    #[should_panic(
        expected = "Sum of metric scores has to be smaller than the evaluation min-score"
    )]
    fn fails_to_parse_evaluation_too_small_min_score() {
        let sdl = r#"
            name: test-scenario
            description: some description
            conditions:
                condition-1:
                    command: executable/path.sh
                    interval: 30
            metrics:
                metric-1:
                    type: MANUAL
                    artifact: true
                    max-score: 10
                metric-2:
                    type: CONDITIONAL
                    max-score: 10
                    condition: condition-1
            evaluations:
                evaluation-1:
                    description: some description
                    metrics:
                        - metric-1
                        - metric-2
                    min-score:
                        absolute: 9999
        "#;
        parse_sdl(sdl).unwrap();
    }

    #[test]
    fn fails_to_parse_too_high_min_score() {
        let evaluation_string = r#"
            description: some description
            metrics:
                - metric-1
                - metric-2
            min_score: 101
        "#;
        let mut evaluation: Evaluation = serde_yaml::from_str(evaluation_string).unwrap();
        assert!(evaluation.formalize().is_err());
    }
}