import type { StandardSchemaV1 } from "@standard-schema/spec";

export type Maybe<T> = T | unknown;

export type MaybePromise<T> = T | Promise<T>;

export type Shape<Input = unknown, Output = unknown> = StandardSchemaV1<Input, Output>;

export type InferShapeInput<S extends Maybe<Shape>, Fallback = unknown> =
  S extends Shape<infer I, unknown> ? I : Fallback;

export type InferShapeOutput<S extends Maybe<Shape>, Fallback = unknown> =
  S extends Shape<unknown, infer O> ? O : Fallback;

export type MaybeShapeArgs<S extends Maybe<Shape>> = S extends Shape
  ? [
      input: InferShapeInput<S>,
    ]
  : [];

export type MaybeShapeListener<S extends Maybe<Shape>> = S extends Shape
  ? (input: InferShapeOutput<S>) => void
  : () => void;

export interface ShapeValidResult {
  valid: true;
  data: unknown;
}

export interface ShapeInvalidResult {
  valid: false;
  issues: readonly StandardSchemaV1.Issue[];
}

export type ShapeValidateResult = ShapeValidResult | ShapeInvalidResult;

export const validateShape = async (shape?: Maybe<Shape>, data?: unknown): Promise<ShapeValidateResult> => {
  if (!shape) {
    return {
      valid: true,
      data,
    };
  }

  const result = await (shape as StandardSchemaV1)["~standard"].validate(data);

  if (result.issues) {
    return {
      valid: false,
      issues: result.issues,
    };
  }

  return {
    valid: true,
    data: result.value,
  };
};