---
import { getBound, getType, type Items } from '../libs/items'
import {
  getRecursiveSchemaObjectItems,
  getSchemaObjectItems,
  isSchemaObjectObject,
  type SchemaObject as SchemaObjectType,
} from '../libs/schemaObject'

import SchemaObject, { type HideSchemaExampleProps } from './schema/SchemaObject.astro'
import SchemaObjectRecursive from './schema/SchemaObjectRecursive.astro'
import Tag from './Tag.astro'
import Tags from './Tags.astro'
import Type from './Type.astro'

interface Props extends HideSchemaExampleProps {
  items: Items
  negated?: boolean | undefined
  nullable?: boolean | undefined
  parents?: SchemaObjectType[]
  schemaObject?: SchemaObjectType | undefined
  type?: string | undefined
}

const { hideExample, items, negated, nullable, parents = [], schemaObject, type } = Astro.props

const itemSchemaObject = getSchemaObjectItems(items)
const nestedParents = schemaObject ? [...parents, schemaObject] : parents
const recursiveSchemaObject = schemaObject && getRecursiveSchemaObjectItems(schemaObject, nestedParents)
const recursiveItem = schemaObject && recursiveSchemaObject ? { recursiveSchemaObject, schemaObject } : undefined

const enumItems = items.enum ?? items.items?.enum
---

{
  items.type && (
    <div>
      {recursiveItem ? (
        <SchemaObjectRecursive
          {negated}
          recursiveSchemaObject={recursiveItem.recursiveSchemaObject}
          schemaObject={recursiveItem.schemaObject}
        />
      ) : (
        <Type>
          {negated && 'not '}
          {getType(items)}
        </Type>
      )}
      {items.format && <Tag>format: {items.format}</Tag>}
    </div>
  )
}
<Tags
  tags={[
    items.default && `default: ${items.default}`,
    nullable && 'nullable',
    getBound(items, 'minimum'),
    getBound(items, 'maximum'),
    items.minLength && `>= ${items.minLength} characters`,
    items.maxLength && `<= ${items.maxLength} characters`,
    items.minItems && `>= ${items.minItems} items`,
    items.maxItems && `<= ${items.maxItems} items`,
    items.pattern && `/${items.pattern}/`,
    items.multipleOf && `multiple of ${items.multipleOf}`,
    items.uniqueItems && 'unique items',
  ]}
/>

{items.const && <Tags label="Allowed value:" tags={[items.const]} />}
{enumItems && <Tags label="Allowed values:" tags={enumItems} />}
{
  itemSchemaObject && isSchemaObjectObject(itemSchemaObject) && !recursiveItem && (
    <SchemaObject parents={nestedParents} nested schemaObject={itemSchemaObject} {hideExample} {type} />
  )
}