import * as V from './validate';

type Constructor<T> = new (...args: any[]) => T;

export { Validator, Primitive } from './validate';

export type Type<T> = T extends V.Validator<infer U> ? U : never;
type OptionalKeys<T> = { [K in keyof T]-?: T[K] & undefined extends never ? never : Required<K> }[keyof T];

export const t = {
  object<T extends Record<string, V.Validator>>(schemas?: T) {
    type U = { [K in keyof T]: Type<T[K]> };
    type O = { [K in OptionalKeys<U>]?: U[K] } & Omit<U, OptionalKeys<U>>;
    return new V.$object<{ [K in keyof O]: O[K] }>(schemas);
  },

  array<T extends V.Validator>(schema?: T) {
    return new V.$array<unknown>(schema);
  },

  tuple<T extends V.Validator[]>(...schemas: T) {
    return new V.$tuple<{ [K in keyof T]: Type<T[K]> }>(...schemas);
  },

  literal<T extends V.Primitive>(v: T) {
    return new V.$literal<T>(v);
  },

  or<T extends V.Validator[]>(...schemas: T) {
    return new V.$or<T extends V.Validator<infer I>[] ? I : unknown>(...schemas);
  },

  symbol() {
    return new V.$symbol();
  },

  record<T extends V.Validator<unknown>>(schema: T) {
    return new V.$record<Type<T>>(schema);
  },

  function() {
    return new V.$function();
  },

  boolean() {
    return new V.$boolean();
  },

  string() {
    return new V.$string();
  },

  number() {
    return new V.$number();
  },

  undefined() {
    return new V.$undefined();
  },

  null() {
    return new V.$null();
  },

  unknown() {
    return new V.$any<unknown>();
  },

  any() {
    return new V.$any();
  },

  as<T>() {
    return new V.$any<T>();
  },

  arraybuffer() {
    return new V.$arraybuffer();
  },

  enum<T extends (string | number)[]>(...values: T) {
    return new V.$enum<T[number]>(...values);
  },

  typedarray<T extends V.TypedArray>(ctor: Constructor<T>) {
    return new V.$typedarray(ctor);
  }
};

export function typeAsserts<T extends V.Validator>(
  validator: T,
  x: unknown,
  path = 'param'
): asserts x is Type<T> {
  validator.errors = [];
  validator.path = path;

  V.setCollect(true);

  if (!validator.validate(x)) {
    const messages = validator.errors.join('\n');
    validator.errors.length = 0;
    V.setCollect(false);

    throw new TypeError(messages);
  }
}