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

impl<'a> ValidationContext<'a> {
  pub(crate) fn validate_extensible(&self, result: &mut ValidationResult) -> Result<bool, ValidationError> {
    if self.extensible {
      if let Some(obj) = self.instance.as_object() {
        result.evaluated_keys.extend(obj.keys().cloned());
      } else if let Some(arr) = self.instance.as_array() {
        result.evaluated_indices.extend(0..arr.len());
      }
    }
    Ok(true)
  }

  pub(crate) fn validate_strictness(
    &self,
    result: &mut ValidationResult,
  ) -> Result<bool, ValidationError> {
    if self.extensible || self.reporter {
      return Ok(true);
    }

    if let Some(obj) = self.instance.as_object() {
      for key in obj.keys() {
        if key == "type" || key == "kind" {
          continue; // Reserved keywords implicitly allowed
        }
        if !result.evaluated_keys.contains(key) && !self.overrides.contains(key) {
          result.errors.push(ValidationError {
            code: "STRICT_PROPERTY_VIOLATION".to_string(),
            message: format!("Unexpected property '{}'", key),
            path: self.join_path(key),
          });
        }
      }
    }

    if let Some(arr) = self.instance.as_array() {
      for i in 0..arr.len() {
        if !result.evaluated_indices.contains(&i) {
          let mut item_path = self.join_path(&i.to_string());
          if let Some(child_instance) = arr.get(i) {
            if let Some(obj) = child_instance.as_object() {
              if let Some(id_str) = obj.get("id").and_then(|v| v.as_str()) {
                item_path = self.join_path(id_str);
              }
            }
          }
          result.errors.push(ValidationError {
            code: "STRICT_ITEM_VIOLATION".to_string(),
            message: format!("Unexpected item at index {}", i),
            path: item_path,
          });
        }
      }
    }

    Ok(true)
  }
}