type Int = int
type Optional = { score?: Int }
type Required = { score: Int }

service Read { next(value: Int): Int }
service Defaults { make(): Int }

export const supervised = (): Int =>
  scoped(defer(() => {
    forkScoped(defer(() => 3))
    3
  }))

export const timedBatches = (source: Stream<Int>): Stream<Int[]> =>
  aggregateWithinStream(source, takeSink(2), scheduleSpaced(1000))

const integer: Schema<Int> = schema()
const optional: SchemaOptional<Int> = schemaOptionalKey(integer)
const shiftedField: SchemaOptional<Int, Int, Read.next> =
  schemaOptionalTransform(
    optional,
    optional,
    (value: Option<Int>): Option<Int> =>
      match value {
        Some(score) => Some(Read.next(score)),
        None => None
      },
    (value: Option<Int>): Option<Int> => value
  )
const shifted: Schema<Optional, Optional, Read.next> =
  schemaStruct({ score: shiftedField })
const defaulted: Schema<Required, Optional, Defaults.make> =
  schemaStruct({
    score: schemaDefaultKey(integer, (): Int => Defaults.make())
  })

export const readShifted = (input: unknown): Optional fails SchemaError uses Read.next =>
  schemaDecode(shifted, input)
export const readDefault = (input: unknown): Required fails SchemaError uses Defaults.make =>
  schemaDecode(defaulted, input)

type Name = string
type OptionalName = { name?: Name }
type RequiredName = { name: Name }

const name: Schema<Name> = schema()
const optionalName: SchemaOptional<Name> = schemaOptionalKey(name)
const requiredNameField: SchemaDecodedOptional<Name> =
  schemaOptionalFromRequired(
    name,
    optionalName,
    (value: Name): Option<Name> => if (value === "") { None } else { Some(value) },
    (value: Option<Name>): Name => match value { Some(current) => current, None => "" }
  )
export const names: Schema<OptionalName, RequiredName> =
  schemaStruct({ name: requiredNameField })

type Scalar = Name | Int
export const scalar: Schema<Scalar> = schemaUnion([name, integer])

service Validation { accept(value: Name): Name fails SchemaIssue }

const checkedName: Schema<Name, Name, Validation.accept> =
  schemaTransform(
    name,
    name,
    (value: Name): Name => Validation.accept(value),
    (value: Name): Option<Name> => Some(value)
  )
export const fallbackName: Schema<Name, Name, Validation.accept> =
  schemaUnion([checkedName, name])

type Nil = null
type Nullable = Name | Nil
type NullableRecord = { name?: Nullable }
const nil: Schema<Nil> = schema()
const nullable: Schema<Nullable> = schemaUnion([name, nil])
export const preserveNull: Schema<NullableRecord> =
  schemaStruct({ name: schemaOptionalKey(nullable) })
export const omitNull: Schema<OptionalName, NullableRecord> =
  schemaStruct({ name: schemaNullToMissingKey(name) })
export const missingName = (): NullableRecord => ({})
export const clearedName = (): NullableRecord => ({ name: null })

export const omittedDefault: Schema<RequiredName, OptionalName> = schemaStruct({
  name: schemaDefaultKey(name, (): Name => "Anonymous", { encodingStrategy: "omit" })
})
export const passedDefault: Schema<RequiredName, OptionalName> = schemaStruct({
  name: schemaDefaultKey(name, (): Name => "Anonymous", { encodingStrategy: "passthrough" })
})

export const defaultedNull: Schema<RequiredName, NullableRecord> = schemaStruct({
  name: schemaDefaultKey(name, (): Name => "Anonymous", { on: "null" })
})
export const readMissingName = (): RequiredName fails SchemaError => schemaDecode(defaultedNull, {})
export const readClearedName = (): RequiredName fails SchemaError => schemaDecode(defaultedNull, { name: null })

type Text = string
type RequiredScore = { score: Int }
type WireRecord = { score?: Text }
service Wire {
  parse(value: Text): Int fails SchemaIssue
  print(value: Int): Text fails SchemaIssue
}
const wireText: Schema<Text> = schema()
const wireScore: Schema<Int, Text, Wire.parse, Wire.print> = schemaTransform(
  wireText, integer,
  (value: Text): Int => Wire.parse(value),
  (value: Int): Text => Wire.print(value)
)
export const encodedDefault: Schema<RequiredScore, WireRecord, Wire.parse, Wire.print> =
  schemaStruct({ score: schemaDefaultKey(wireScore,
    (): Text => "41", { on: "encoded", encodingStrategy: "omit" }) })

type ConstructorInput = { score?: Int }
type ConstructorRecord = { score: Int }
const constructorRecord: Schema<ConstructorRecord> = schemaStruct({ score: integer })

export const makeScore = (input: ConstructorInput): ConstructorRecord fails SchemaIssue => {
  const score = match input.score { Some(value) => value, None => 4 }
  schemaMake(constructorRecord, { score: score })
}

type DefaultRecord = { score: Int }
type DefaultInput = { score?: Int }
type NestedRecord = { settings: DefaultRecord }
type NestedInput = { settings?: DefaultInput }

export const constructorDefaults: Schema<DefaultRecord, DefaultRecord, never, never, DefaultInput> =
  schemaStruct({ score: schemaConstructorDefault(integer, (): Int => 4) })
export const nestedDefaults: Schema<NestedRecord, NestedRecord, never, never, NestedInput> =
  schemaStruct({ settings: schemaConstructorDefault(constructorDefaults,
    (): DefaultInput => ({})) })
export const constructorDefaultsList: Schema<DefaultRecord[], DefaultRecord[], never, never, DefaultInput[]> =
  schemaArray(constructorDefaults)
export const constructDefaults = (input: NestedInput): NestedRecord fails SchemaIssue =>
  schemaMake(nestedDefaults, input)

type SettingsRecord = { settings: DefaultRecord }
type SettingsWire = { settings?: DefaultRecord }
type SettingsInput = { settings: DefaultInput }
type OptionalSettingsInput = { settings?: DefaultInput }
type NullableSettingsWire = { settings?: DefaultRecord | null }

export const wireDefaultSettings: Schema<SettingsRecord, SettingsWire, never, never, SettingsInput> =
  schemaStruct({ settings: schemaDefaultKey(constructorDefaults,
    (): DefaultRecord => ({ score: 8 })) })
export const optionalSettings: Schema<SettingsWire, NullableSettingsWire, never, never, OptionalSettingsInput> =
  schemaStruct({ settings: schemaNullToMissingKey(constructorDefaults) })
export const constructSettings = (input: SettingsInput): SettingsRecord fails SchemaIssue =>
  schemaMake(wireDefaultSettings, input)

type Tree = { score: Int, children: Tree[] }
type TreeInput = { score?: Int, children?: TreeInput[] }

export const treeDefaults: Schema<Tree, Tree, never, never, TreeInput> = schemaRecursive(
  (self: Schema<Tree, Tree, never, never, TreeInput>): Schema<Tree, Tree, never, never, TreeInput> =>
    schemaStruct({
      score: schemaConstructorDefault(integer, (): Int => 4),
      children: schemaConstructorDefault(schemaArray(self), (): TreeInput[] => [])
    })
)
export const constructTree = (input: TreeInput): Tree fails SchemaIssue =>
  schemaMake(treeDefaults, input)

type WireTree = { score: Text, children: WireTree[] }

export const wireTree: Schema<Tree, WireTree, Wire.parse, Wire.print, TreeInput> = schemaRecursive(
  (self: Schema<Tree, WireTree, Wire.parse, Wire.print, TreeInput>): Schema<Tree, WireTree, Wire.parse, Wire.print, TreeInput> =>
    schemaStruct({
      score: schemaConstructorDefault(wireScore, (): Int => 4),
      children: schemaConstructorDefault(schemaArray(self), (): TreeInput[] => [])
    })
)
export const readWireTree = (input: unknown): Tree fails SchemaError uses Wire.parse =>
  schemaDecode(wireTree, input)
export const writeWireTree = (input: Tree): WireTree fails SchemaError uses Wire.print =>
  schemaEncode(wireTree, input)
export const constructWireTree = (input: TreeInput): Tree fails SchemaIssue =>
  schemaMake(wireTree, input)

export const dualDefaultField: SchemaEncodedOptionalConstructorDefault<Int> =
  schemaConstructorDefault(schemaDefaultKey(integer, (): Int => 8), (): Int => 4)
export const dualDefaultScores: Schema<Required, Optional, never, never, Optional> =
  schemaStruct({ score: dualDefaultField })
export const optionalDefaultField: SchemaOptionalConstructorDefault<Int> =
  schemaConstructorDefault(schemaOptionalKey(integer), (): Int => 4)
export const optionalDefaultScores: Schema<Optional> =
  schemaStruct({ score: optionalDefaultField })
export const makeDualDefaults = (input: Optional): Required fails SchemaIssue =>
  schemaMake(dualDefaultScores, input)

type OptionScores = { score: Option<Int> }
const constructorFirst: SchemaConstructorDefault<Int> =
  schemaConstructorDefault(integer, (): Int => 4)
export const adapterAfterDefault: SchemaEncodedOptionalConstructorDefault<Int> =
  schemaDefaultKey(constructorFirst, (): Int => 8)
export const adapterAfterDefaults: Schema<Required, Optional, never, never, Optional> =
  schemaStruct({ score: adapterAfterDefault })
export const optionAfterDefaults: Schema<OptionScores, Optional> =
  schemaStruct({ score: schemaOptionFromOptionalKey(constructorFirst) })
export const makeAdapterAfterDefault = (input: Optional): Required fails SchemaIssue =>
  schemaMake(adapterAfterDefaults, input)
export const makeAdaptedOption = (input: OptionScores): OptionScores fails SchemaIssue =>
  schemaMake(optionAfterDefaults, input)

type DefaultWireTree = { score: Int, children?: DefaultWireTree[] }
export const defaultedTree: Schema<Tree,DefaultWireTree,never,never,TreeInput> = schemaRecursive(
  (self: Schema<Tree,DefaultWireTree,never,never,TreeInput>): Schema<Tree,DefaultWireTree,never,never,TreeInput> =>
    schemaStruct({
      score: schemaConstructorDefault(integer, (): Int => 4),
      children: schemaDefaultKey(
        schemaConstructorDefault(schemaArray(self), (): TreeInput[] => []),
        (): Tree[] => [{ score: 8, children: [] }])
    })
)
export const makeDefaultedTree = (input: TreeInput): Tree fails SchemaIssue =>
  schemaMake(defaultedTree, input)
export const readDefaultedTree = (input: unknown): Tree fails SchemaError =>
  schemaDecode(defaultedTree, input)