export type Args = {[_: string]: any};

export interface Validator {
  type: string;
  check: (value: any) => Promise<Args|undefined>|Args|undefined;
  message: (value: any, args?: Args) => Promise<string|undefined>|string|undefined;
}

export interface ValidationError {
  type: string;
  param?: string[];
  message?: string|null;
  args?: Args;
}

export type Validatable = Schema|Validator|Validator[];

export const ArraySymbol: unique symbol = Symbol("ArraySymbol");
export type Schema = {[key: string]: Validatable}|{[ArraySymbol]: Validatable};

export async function validate(value: any, validators: Validatable): Promise<ValidationError[]|undefined> {
  if (instanceofValidatorArray(validators) || instanceofValidator(validators)) {
    return validateValue(value, validators);
  } else {
    return validateSchema(value, validators);
  }
}

function instanceofValidator(value: any): value is Validator {
  return value &&
    value.hasOwnProperty("type") && typeof value.type === "string" &&
    value.hasOwnProperty("check") && typeof value.check === "function" &&
    value.hasOwnProperty("message") && typeof value.message === "function";
}

function instanceofValidatorArray(value: any): value is Validator[] {
  return Array.isArray(value) && value.every(x => instanceofValidator(x));
}

async function validateValue(value: any, validators: Validator|Validator[]): Promise<ValidationError[]> {
  if (!Array.isArray(validators)) {
    validators = [validators];
  }
  const result: ValidationError[] = [];
  for (const validator of validators) {
    const args = await validator.check(value);
    if (args !== undefined) {
      const message = await validator.message(value, args);
      result.push({
        type: validator.type,
        args,
        message
      });
    }
  }
  return result;
}

async function validateSchema(value: any, validators: Schema): Promise<ValidationError[]> {
  if (validators.hasOwnProperty(ArraySymbol)) {
    const v = validators as {[ArraySymbol]: Validatable};
    if (Array.isArray(value)) {
      const arr = await Promise.all(value.map(val => validate(val, v[ArraySymbol])));
      const errors = arr.flatMap((val, idx) => (val ?? []).map(error => ({
        ...error,
        param: [`[${idx}]`, ...(error.param || [])]
      })));
      return errors;
    } else {
      return [{
        type: "array",
        param: ["[]"],
        message: "Array expected!",
        args: {}
      }];
    }
  }
  const v = validators as {[key: string]: Validatable};
  const valErrors: ValidationError[] = [];
  for (const prop in validators) {
    if (!validators.hasOwnProperty(prop)) {
      continue;
    }
    if (value.hasOwnProperty(prop)) {
      const errors = await validate(value[prop], v[prop]);
      valErrors.push(...(errors ?? []));
    } else {
      valErrors.push({
        type: "property",
        param: [prop],
        message: `Property '${prop}' expected but not found!`,
        args: {property: prop}
      });
    }
  }
  return valErrors;
}