import z from 'zod'

// ------------------------------------------------------------------
// Infrastructure
// ------------------------------------------------------------------

export type TSchema = { type: string }

export type TOptional<Type extends TSchema = TSchema> = Type & { '~optional': true }

export interface TRef<Ref extends string> extends TSchema { 
  type: 'Ref', 
  ref: Ref 
}
export interface TString extends TSchema { 
  type: 'String' 
}

export type TProperties = Record<PropertyKey, TSchema>

export interface TObject<Properties extends TProperties> extends TSchema {
  type: 'Object'
  properties: Properties
}

// ------------------------------------------------------------------
// Mapping
// ------------------------------------------------------------------
type ZodType = z.core.SomeType

type TFromRef<Context extends TProperties, Ref extends string> = (
  Ref extends keyof Context
    ? TFromType<Context, Context[Ref]>
    : z.ZodNever
)
type TFromProperty<Context extends TProperties, Type extends TSchema,
  WithType extends ZodType = TFromType<Context, Type>,
  WithOptional extends ZodType = Type extends TOptional ? z.ZodOptional<WithType> : WithType,
> = WithOptional

type TFromObject<Context extends TProperties, Properties extends TProperties,
  // Mapped Type Regression Here
  //
  // Ok:   6.0.3
  // Fail: 7.0.1-rc
  //
  // Error: Type '{ [Key in keyof Properties]: Properties[Key] extends 
  //  TOptional<TSchema> ? ZodOptional<TFromType<Context, Properties[Key]>>  .....
  Result extends ZodType = z.ZodObject<{
    [Key in keyof Properties]: TFromProperty<Context, Properties[Key]>
  }>
> = Result

type TFromString = z.ZodString

type TFromType<Context extends TProperties, Type extends TSchema> = (
  Type extends TObject<infer Properties extends TProperties> ? TFromObject<Context, Properties> :
  Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref> :
  Type extends TString ? TFromString :
  z.ZodNever
)

// ------------------------------------------------------------------
// Usage
// ------------------------------------------------------------------

type Input = TObject<{
  x: TRef<'A'>,
  y: TRef<'A'>,
  z: TRef<'A'>
}>
type Output = TFromType<{    // type Output = z.ZodObject<{
  A: TString                 //   x: z.ZodString;
}, Input>                    //   y: z.ZodString;
                             //   z: z.ZodString;
                             // }, z.core.$strip>