/**
 * @typedef {{ path: string, message: string, keyword: string }} ValidationError
 */

function validate(data, schema, path, rootSchema) {
  path = path || '';
  rootSchema = rootSchema || schema;

  if (schema === true) return [];
  if (schema === false) return [{ path, message: 'Schema is false', keyword: 'false schema' }];

  const errors = [];

  // $ref short-circuits all other keywords (Draft-07 spec)
  if (schema.$ref) {
    const resolved = resolveRef(schema.$ref, rootSchema);
    if (resolved) return validate(data, resolved, path, rootSchema);
    return [{ path, message: `Cannot resolve $ref "${schema.$ref}"`, keyword: '$ref' }];
  }

  // Type check first — no point checking string keywords on a number
  if (schema.type !== undefined && !typeMatches(data, schema.type)) {
    const expected = Array.isArray(schema.type) ? schema.type.join(' | ') : schema.type;
    return [{ path, message: `Expected "${expected}" but got "${getType(data)}"`, keyword: 'type' }];
  }

  if (typeof data === 'string') errors.push(...validateString(data, schema, path));
  if (typeof data === 'number') errors.push(...validateNumber(data, schema, path));
  if (Array.isArray(data))     errors.push(...validateArray(data, schema, path, rootSchema));
  if (isPlainObject(data))     errors.push(...validateObject(data, schema, path, rootSchema));

  // Combiners
  if (schema.allOf) schema.allOf.forEach(s => errors.push(...validate(data, s, path, rootSchema)));
  if (schema.anyOf && !schema.anyOf.some(s => validate(data, s, path, rootSchema).length === 0))
    errors.push({ path, message: 'Does not match any schema in "anyOf"', keyword: 'anyOf' });
  // ...oneOf, not, if/then/else similarly

  return errors;
}

function validateNumber(val, schema, path) {
  const errors = [];

  if (typeof schema.minimum === 'number') {
    if (schema.exclusiveMinimum === true) {
      // Draft-04 style
      if (val <= schema.minimum)
        errors.push({ path, message: `${val} must be > ${schema.minimum}`, keyword: 'exclusiveMinimum' });
    } else {
      if (val < schema.minimum)
        errors.push({ path, message: `${val} must be >= ${schema.minimum}`, keyword: 'minimum' });
    }
  }

  // Draft-06/07 style: exclusiveMinimum as a number
  if (typeof schema.exclusiveMinimum === 'number') {
    if (val <= schema.exclusiveMinimum)
      errors.push({ path, message: `${val} must be > ${schema.exclusiveMinimum}`, keyword: 'exclusiveMinimum' });
  }

  // ... same pattern for maximum / exclusiveMaximum

  return errors;
}

function resolveRef(ref, rootSchema) {
  if (!ref.startsWith('#')) return null;  // external refs not supported
  const fragment = ref.slice(1);
  if (fragment === '' || fragment === '/') return rootSchema;  // bare # → root
  const parts = fragment.slice(1)
    .split('/')
    .map(p => p.replace(/~1/g, '/').replace(/~0/g, '~'));  // JSON Pointer unescaping
  let cur = rootSchema;
  for (const part of parts) {
    if (cur === null || typeof cur !== 'object') return null;
    cur = cur[part];
  }
  return cur !== undefined ? cur : null;
}

if (schema.if !== undefined) {
  const ifErrors = validate(data, schema.if, path, rootSchema);
  if (ifErrors.length === 0) {
    // condition passed → apply then
    if (schema.then !== undefined)
      errors.push(...validate(data, schema.then, path, rootSchema));
  } else {
    // condition failed → apply else
    if (schema.else !== undefined)
      errors.push(...validate(data, schema.else, path, rootSchema));
  }
}

const vm = require('vm');
const modObj = { exports: {} };
vm.runInContext(extractedScript, vm.createContext({
  module: modObj, exports: modObj.exports,
  window: { addEventListener: () => {} },
  document: { getElementById: () => ({}), querySelectorAll: () => [], addEventListener: () => {} },
  Date, JSON, RegExp, Number, Math, Array, Object, String, Boolean, console
}));

const { validate, getType, typeMatches, isValidEmail, ... } = modObj.exports;