use crate::validator::context::ValidationContext;
use crate::validator::error::ValidationError;
use crate::validator::result::ValidationResult;

impl<'a> ValidationContext<'a> {
  pub(crate) fn validate_cases(
    &self,
    result: &mut ValidationResult,
  ) -> Result<bool, ValidationError> {
    if let Some(cases) = &self.schema.cases {
      for case in cases {
        if let Some(ref when_schema) = case.when {
          let derived_when = self.derive_for_schema(when_schema, true);
          let when_res = derived_when.validate()?;

          // Evaluates all cases independently.
          if when_res.is_valid() {
            result
              .evaluated_keys
              .extend(when_res.evaluated_keys.clone());
            result
              .evaluated_indices
              .extend(when_res.evaluated_indices.clone());

            if let Some(ref then_schema) = case.then {
              let derived_then = self.derive_for_schema(then_schema, true);
              result.merge(derived_then.validate()?);
            }
          } else {
            if let Some(ref else_schema) = case.else_ {
              let derived_else = self.derive_for_schema(else_schema, true);
              result.merge(derived_else.validate()?);
            }
          }
        } else if let Some(ref else_schema) = case.else_ {
          // A rule with a missing `when` fires the `else` indiscriminately
          let derived_else = self.derive_for_schema(else_schema, true);
          result.merge(derived_else.validate()?);
        }
      }
    }

    Ok(true)
  }
}