import { text } from '@opensaas/stack-core/fields'

text(options?: {
  validation?: {
    isRequired?: boolean
    length?: { min?: number; max?: number }
  }
  isIndexed?: boolean | 'unique'
  db?: {
    map?: string
  }
  ui?: {
    displayMode?: 'input' | 'textarea'
    [key: string]: unknown
  }
  access?: FieldAccess
  hooks?: FieldHooks<string, string>
  defaultValue?: string
})

title: text({
  validation: {
    isRequired: true,
    length: { min: 3, max: 100 },
  },
})

email: text({
  isIndexed: 'unique',
  validation: { isRequired: true },
})

firstName: text({
  db: { map: 'first_name' },
})

emailAddress: text({
  isIndexed: 'unique',
  db: { map: 'email' },
})

firstName    String @map("first_name")
emailAddress String @unique @map("email")

description: text({
  ui: { displayMode: 'textarea' },
})

import { integer } from '@opensaas/stack-core/fields'

integer(options?: {
  validation?: {
    isRequired?: boolean
    min?: number
    max?: number
  }
  ui?: {
    [key: string]: unknown
  }
  access?: FieldAccess
  hooks?: FieldHooks<number, number>
  defaultValue?: number
})

age: integer({
  validation: {
    isRequired: true,
    min: 0,
    max: 150,
  },
})

score: integer({ defaultValue: 0 })

import { decimal } from '@opensaas/stack-core/fields'

decimal(options?: {
  precision?: number
  scale?: number
  validation?: {
    isRequired?: boolean
    min?: string
    max?: string
  }
  defaultValue?: string
  db?: {
    map?: string
    isNullable?: boolean
  }
  isIndexed?: boolean | 'unique'
  ui?: {
    [key: string]: unknown
  }
  access?: FieldAccess
  hooks?: FieldHooks<Decimal, Decimal>
})

price: decimal({
  precision: 10, // Max 10 digits total
  scale: 2, // 2 decimal places
})
// Can store: 12345678.90 (10 digits, 2 decimals)

coordinates: decimal({
  precision: 18,
  scale: 8, // 8 decimal places for GPS precision
})

price: decimal({
  precision: 10,
  scale: 2,
  validation: {
    isRequired: true,
    min: '0',
    max: '999999.99',
  },
})

balance: decimal({
  defaultValue: '0.0000',
  precision: 18,
  scale: 4,
})

latitude: decimal({
  db: { map: 'lat' },
  precision: 18,
  scale: 8,
})

price: decimal({
  validation: { isRequired: true },
  db: { isNullable: false }, // Enforce NOT NULL at database level
})

accountNumber: decimal({
  isIndexed: 'unique',
  precision: 20,
  scale: 0,
})

price Decimal @db.Decimal(10, 2)

import type { Decimal } from 'decimal.js'

import { Decimal } from 'decimal.js'

// Creating records
const product = await context.db.product.create({
  data: {
    name: 'Widget',
    price: '19.99', // Can use string
    // price: 19.99,  // or number (converted to Decimal)
  },
})

// Performing precise calculations
const quantity = 3
const subtotal = product.price.times(quantity) // Decimal: 59.97
const tax = subtotal.times('0.1') // Decimal: 5.997
const total = subtotal.plus(tax) // Decimal: 65.967

// Rounding for currency
const totalCents = total.toDecimalPlaces(2) // Decimal: 65.97

// Converting to string/number
const priceString = product.price.toString() // '19.99'
const priceNumber = product.price.toNumber() // 19.99

import { checkbox } from '@opensaas/stack-core/fields'

checkbox(options?: {
  defaultValue?: boolean
  ui?: {
    [key: string]: unknown
  }
  access?: FieldAccess
  hooks?: FieldHooks<boolean, boolean>
})

isPublished: checkbox({ defaultValue: false })
emailVerified: checkbox({ defaultValue: true })

import { timestamp } from '@opensaas/stack-core/fields'

timestamp(options?: {
  defaultValue?: { kind: 'now' } | Date
  ui?: {
    [key: string]: unknown
  }
  access?: FieldAccess
  hooks?: FieldHooks<Date, Date>
})

createdAt: timestamp({
  defaultValue: { kind: 'now' },
})

publishedAt: timestamp()

import { calendarDay } from '@opensaas/stack-core/fields'

calendarDay(options?: {
  validation?: {
    isRequired?: boolean
  }
  defaultValue?: string
  isIndexed?: boolean | 'unique'
  db?: {
    map?: string
    isNullable?: boolean
  }
  ui?: {
    [key: string]: unknown
  }
  access?: FieldAccess
  hooks?: FieldHooks<Date, Date>
})

birthDate: calendarDay({
  validation: { isRequired: true },
})

startDate: calendarDay({
  defaultValue: '2025-01-01',
})

eventDate: calendarDay({
  isIndexed: true,
})

publishDate: calendarDay({
  db: { map: 'publish_date' },
})

endDate: calendarDay({
  db: { isNullable: false },
})

birthDate  DateTime  @db.Date
startDate  DateTime? @db.Date @default("2025-01-01")
eventDate  DateTime? @db.Date @index

import { password } from '@opensaas/stack-core/fields'

password(options?: {
  validation?: {
    isRequired?: boolean
  }
  ui?: {
    [key: string]: unknown
  }
  access?: FieldAccess
  hooks?: FieldHooks<string, HashedPassword>
})

password: password({
  validation: { isRequired: true },
})

// Creating a user - password is automatically hashed
const user = await context.db.user.create({
  data: {
    email: 'user@example.com',
    password: 'plaintextPassword', // Hashed before storage
  },
})

// Authenticating - use the compare() method
const user = await context.db.user.findUnique({
  where: { email: 'user@example.com' },
})

if (user && (await user.password.compare('plaintextPassword'))) {
  // Password is correct
}

class HashedPassword extends String {
  /**
   * Compare plaintext password with hashed password
   * @param plaintext - The plaintext password to verify
   * @returns Promise resolving to true if password matches
   */
  compare(plaintext: string): Promise<boolean>
}

import { select } from '@opensaas/stack-core/fields'

select(options: {
  options: Array<{ label: string; value: string }>
  validation?: {
    isRequired?: boolean
  }
  defaultValue?: string
  ui?: {
    displayMode?: 'select' | 'segmented-control' | 'radio'
    [key: string]: unknown
  }
  access?: FieldAccess
  hooks?: FieldHooks<string, string>
})

status: select({
  options: [
    { label: 'Draft', value: 'draft' },
    { label: 'Published', value: 'published' },
    { label: 'Archived', value: 'archived' },
  ],
})

status: select({
  options: [
    /* ... */
  ],
  defaultValue: 'draft',
})

import { relationship } from '@opensaas/stack-core/fields'

relationship(options: {
  ref: string
  many?: boolean
  db?: {
    foreignKey?: boolean
  }
  ui?: {
    displayMode?: 'select' | 'cards'
    [key: string]: unknown
  }
  access?: FieldAccess
})

// Bidirectional relationship
User: list({
  fields: {
    posts: relationship({
      ref: 'Post.author',
      many: true,
    }),
  },
})

Post: list({
  fields: {
    author: relationship({
      ref: 'User.posts',
    }),
  },
})

// List-only relationship
Post: list({
  fields: {
    category: relationship({
      ref: 'Category', // No field specified - creates synthetic field
    }),
  },
})

// Explicit foreign key placement
User: list({
  fields: {
    account: relationship({
      ref: 'Account.user',
      db: { foreignKey: true }, // User table stores accountId
    }),
  },
}),
Account: list({
  fields: {
    user: relationship({
      ref: 'User.account', // No foreign key on this side
    }),
  },
})

model User {
  accountId String?  @unique
  account   Account? @relation(fields: [accountId], references: [id])
}

model Account {
  user User?
}

User: list({
  fields: {
    posts: relationship({ ref: 'Post.author', many: true }),
  },
})

Post: list({
  fields: {
    author: relationship({ ref: 'User.posts' }),
  },
})

Post: list({
  fields: {
    author: relationship({ ref: 'User.posts' }),
  },
})

User: list({
  fields: {
    posts: relationship({ ref: 'Post.author', many: true }),
  },
})

User: list({
  fields: {
    profile: relationship({ ref: 'Profile.user' }),
  },
})

Profile: list({
  fields: {
    user: relationship({ ref: 'User.profile' }),
  },
})

import { json } from '@opensaas/stack-core/fields'

json(options?: {
  validation?: {
    isRequired?: boolean
  }
  ui?: {
    placeholder?: string
    rows?: number
    formatted?: boolean
    [key: string]: unknown
  }
  access?: FieldAccess
  hooks?: FieldHooks<unknown, unknown>
  defaultValue?: unknown
})

metadata: json({
  validation: { isRequired: false },
  ui: {
    placeholder: 'Enter JSON data...',
    rows: 10,
    formatted: true,
  },
})

// Creating with JSON data
const item = await context.db.item.create({
  data: {
    metadata: {
      tags: ['tag1', 'tag2'],
      settings: { theme: 'dark', notifications: true },
    },
  },
})

// Querying returns parsed JSON
const item = await context.db.item.findUnique({
  where: { id: '...' },
})
console.log(item.metadata.tags) // ['tag1', 'tag2']

import { virtual } from '@opensaas/stack-core/fields'

virtual(options: {
  type: string
  hooks: {
    resolveOutput: (args: {
      operation: 'query'
      value: unknown
      item: TItem
      listKey: string
      fieldName: string
      context: AccessContext
    }) => unknown
    resolveInput?: (args: {
      operation: 'create' | 'update'
      inputValue: unknown
      item?: TItem
      listKey: string
      fieldName: string
      context: AccessContext
    }) => Promise<unknown> | unknown
  }
  ui?: {
    [key: string]: unknown
  }
  access?: FieldAccess
})

fullName: virtual({
  type: 'string', // or 'number', 'boolean', 'Date', etc.
  hooks: {
    resolveOutput: ({ item }) => `${item.firstName} ${item.lastName}`,
  },
})

import Decimal from 'decimal.js'

totalPrice: virtual({
  type: "import('decimal.js').Decimal",
  hooks: {
    resolveOutput: ({ item }) => new Decimal(item.price).times(item.quantity),
  },
})

import Decimal from 'decimal.js'

totalPrice: virtual({
  type: { value: Decimal, from: 'decimal.js' },
  hooks: {
    resolveOutput: ({ item }) => new Decimal(item.price).times(item.quantity),
  },
})

// With custom name (when constructor name doesn't match export)
customField: virtual({
  type: {
    value: MyClass,
    from: '@myorg/types',
    name: 'MyExportedType', // Optional
  },
  hooks: {
    resolveOutput: ({ item }) => new MyClass(item.data),
  },
})

type TypeDescriptor =
  | string // Primitive or import string
  | {
      value: new (...args: any[]) => any // Constructor/class
      from: string // Import path
      name?: string // Optional custom name
    }

displayName: virtual({
  type: 'string',
  hooks: {
    resolveOutput: ({ item }) => {
      return `${item.name} (${item.email})`
    },
  },
})

syncToExternal: virtual({
  type: 'boolean',
  hooks: {
    resolveInput: async ({ item, operation }) => {
      // Side effect: sync to external API
      if (operation === 'update') {
        await syncToExternalAPI(item)
      }
      return undefined // Return value is ignored
    },
    resolveOutput: () => true,
  },
})

User: list({
  fields: {
    firstName: text(),
    lastName: text(),
    fullName: virtual({
      type: 'string',
      hooks: {
        resolveOutput: ({ item }) => `${item.firstName} ${item.lastName}`,
      },
    }),
  },
})

// Usage
const user = await context.db.user.findUnique({
  where: { id },
  select: { firstName: true, lastName: true, fullName: true },
})
console.log(user.fullName) // "John Doe"

Order: list({
  fields: {
    items: json(), // Array of { price: number, quantity: number }
    total: virtual({
      type: 'number',
      hooks: {
        resolveOutput: ({ item }) => {
          if (!item.items || !Array.isArray(item.items)) return 0
          return item.items.reduce((sum, item) => sum + item.price * item.quantity, 0)
        },
      },
    }),
  },
})

Post: list({
  fields: {
    title: text(),
    content: text(),
    searchIndexSync: virtual({
      type: 'boolean',
      hooks: {
        resolveInput: async ({ item, operation }) => {
          // Update search index when post is created or updated
          if (operation === 'create' || operation === 'update') {
            await updateSearchIndex(item)
          }
          return undefined
        },
        resolveOutput: () => true,
      },
    }),
  },
})

// ❌ Virtual field NOT computed
const user = await context.db.user.findUnique({
  where: { id },
})
// user.fullName is undefined

// ✅ Virtual field IS computed
const user = await context.db.user.findUnique({
  where: { id },
  select: { firstName: true, lastName: true, fullName: true },
})
// user.fullName is "John Doe"

type FieldAccess = {
  read?: AccessControl
  create?: AccessControl
  update?: AccessControl
}

type AccessControl = (args: {
  session: Session
  item?: T
  context: AccessContext
}) => boolean | Promise<boolean>

internalNotes: text({
  access: {
    read: ({ session }) => session?.role === 'admin',
    create: ({ session }) => session?.role === 'admin',
    update: ({ session }) => session?.role === 'admin',
  },
})

type FieldHooks<TInput, TOutput> = {
  resolveInput?: (args: {
    operation: 'create' | 'update'
    inputValue: TInput | undefined
    item?: TItem
    listKey: string
    fieldName: string
    context: AccessContext
  }) => Promise<TInput | undefined> | TInput | undefined

  resolveOutput?: (args: {
    operation: 'query'
    value: TInput | undefined
    item: TItem
    listKey: string
    fieldName: string
    context: AccessContext
  }) => TOutput | undefined

  beforeOperation?: (args: {
    operation: 'create' | 'update' | 'delete'
    resolvedValue: TInput | undefined
    item?: TItem
    listKey: string
    fieldName: string
    context: AccessContext
  }) => Promise<void> | void

  afterOperation?: (args: {
    operation: 'create' | 'update' | 'delete' | 'query'
    value: TInput | TOutput | undefined
    item: TItem
    listKey: string
    fieldName: string
    context: AccessContext
  }) => Promise<void> | void
}

slug: text({
  hooks: {
    resolveInput: async ({ inputValue, item }) => {
      // Auto-generate slug from title if not provided
      if (!inputValue && item?.title) {
        return item.title.toLowerCase().replace(/\s+/g, '-')
      }
      return inputValue
    },
  },
})

profileImage: text({
  hooks: {
    resolveOutput: ({ value }) => {
      // Add CDN prefix to image URLs
      return value ? `https://cdn.example.com/${value}` : null
    },
  },
})

status: select({
  options: [
    /* ... */
  ],
  hooks: {
    beforeOperation: async ({ operation, resolvedValue, item }) => {
      // Log status changes
      if (operation === 'update' && item.status !== resolvedValue) {
        await auditLog.record({
          event: 'status_change',
          from: item.status,
          to: resolvedValue,
        })
      }
    },
  },
})

thumbnail: text({
  hooks: {
    afterOperation: async ({ operation, value, item }) => {
      if (operation === 'delete' && value) {
        // Delete file from storage
        await deleteFromCDN(value)
      } else if (operation === 'update' && value) {
        // Invalidate CDN cache
        await invalidateCDNCache(value)
      }
    },
  },
})

content: text({
  ui: {
    displayMode: 'textarea',
    placeholder: 'Enter your content...',
    rows: 10,
    // Custom UI options
    spellcheck: true,
    autocomplete: 'off',
  },
})

import { SlugField } from './components/SlugField'

slug: text({
  ui: {
    component: SlugField, // Use custom component for this field only
  },
})

status: select({
  options: [
    /* ... */
  ],
  defaultValue: 'draft',
})

score: integer({ defaultValue: 0 })

isPublished: checkbox({ defaultValue: false })

createdAt: timestamp({ defaultValue: { kind: 'now' } })

getZodSchema(
  fieldName: string,
  operation: 'create' | 'update'
): z.ZodTypeAny

getZodSchema: (fieldName, operation) => {
  const baseSchema = z.string({
    message: `${fieldName} must be text`,
  })

  const withValidation = options?.validation?.isRequired
    ? baseSchema.min(1, { message: `${fieldName} is required` })
    : baseSchema.optional()

  return withValidation
}

getPrismaType(fieldName: string): {
  type: string
  modifiers?: string
}

getPrismaType: (fieldName) => {
  return {
    type: 'String',
    modifiers: options?.validation?.isRequired ? undefined : '?',
  }
}

getTypeScriptType(): {
  type: string
  optional: boolean
}

getTypeScriptType: () => {
  return {
    type: 'string',
    optional: !options?.validation?.isRequired,
  }
}

getTypeScriptImports(): Array<{
  names: string[]
  from: string
  typeOnly?: boolean
}>

getTypeScriptImports: () => {
  return [
    {
      names: ['HashedPassword'],
      from: '@opensaas/stack-core',
      typeOnly: false,
    },
  ]
}

import type { BaseFieldConfig } from '@opensaas/stack-core'
import { z } from 'zod'

export type EmailField = BaseFieldConfig & {
  type: 'email'
  requireVerification?: boolean
}

export function email(options?: Omit<EmailField, 'type'>): EmailField {
  return {
    type: 'email',
    ...options,

    getZodSchema: (fieldName, operation) => {
      const schema = z.string().email({
        message: `${fieldName} must be a valid email`,
      })
      return options?.validation?.isRequired ? schema : schema.optional()
    },

    getPrismaType: (fieldName) => {
      return {
        type: 'String',
        modifiers: options?.validation?.isRequired ? undefined : '?',
      }
    },

    getTypeScriptType: () => {
      return {
        type: 'string',
        optional: !options?.validation?.isRequired,
      }
    },
  }
}

import { richText } from '@opensaas/stack-tiptap/fields'

content: richText({
  ui: {
    minHeight: 300,
    maxHeight: 800,
    placeholder: 'Write your content...',
  },
})

import { image, file } from '@opensaas/stack-storage/fields'

avatar: image({
  storage: 's3',
  validation: { isRequired: true },
  transformations: {
    thumbnail: { width: 150, height: 150 },
    large: { width: 1200, height: 1200 },
  },
})

document: file({
  storage: 'local',
  validation: {
    maxSize: 10 * 1024 * 1024, // 10MB
    allowedTypes: ['application/pdf', 'text/plain'],
  },
})

text({
  validation: {
    isRequired: true,
    length: { min: 3, max: 100 },
  },
})

integer({
  validation: {
    isRequired: true,
    min: 0,
    max: 100,
  },
})

{
  "field": "title",
  "message": "Title must be at least 3 characters"
}

// ✅ Good: Use integer for numbers
age: integer({ validation: { min: 0, max: 150 } })

// ❌ Bad: Don't use text for numbers
age: text({ validation: { length: { max: 3 } } })

// ✅ Good: Validate required fields and constraints
email: text({
  isIndexed: 'unique',
  validation: {
    isRequired: true,
    length: { max: 255 },
  },
})

// ❌ Bad: No validation
email: text()

// ✅ Good: Use relationship field
author: relationship({ ref: 'User.posts' })

// ❌ Bad: Don't manually manage IDs with text
authorId: text()

// ✅ Good: Index fields used in queries
email: text({
  isIndexed: 'unique',
  validation: { isRequired: true },
})

slug: text({
  isIndexed: true,
})

// ✅ Good: Use hooks for data transformation
email: text({
  hooks: {
    resolveInput: async ({ inputValue }) => {
      return inputValue?.toLowerCase().trim()
    },
  },
})

// ❌ Bad: Don't transform in application code