import { Core } from "@evolution-sdk/evolution"

// Define schema
const OutputReferenceSchema = Core.TSchema.Struct({
  transaction_id: Core.TSchema.ByteArray,
  output_index: Core.TSchema.Integer
})

// Extract TypeScript type
type OutputReference = typeof OutputReferenceSchema.Type
// {
//   transaction_id: Uint8Array
//   output_index: bigint  
// }

// Create codec
const OutputReferenceCodec = Core.Data.withSchema(OutputReferenceSchema)

// Use it
const outRef: OutputReference = {
  transaction_id: Core.Bytes.fromHex("a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2"),
  output_index: 0n
}

const cborHex = OutputReferenceCodec.toCBORHex(outRef)
const decoded = OutputReferenceCodec.fromCBORHex(cborHex)

import { Core } from "@evolution-sdk/evolution"

const HashSchema = Core.TSchema.ByteArray

type Hash = typeof HashSchema.Type
// Uint8Array

const txHash: Hash = Core.Bytes.fromHex(
  "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2"
)

import { Core } from "@evolution-sdk/evolution"

const AmountSchema = Core.TSchema.Integer

type Amount = typeof AmountSchema.Type
// bigint

const lovelace: Amount = 5000000n

import { Core } from "@evolution-sdk/evolution"

const AddressSchema = Core.TSchema.Struct({
  payment_credential: Core.TSchema.ByteArray,
  stake_credential: Core.TSchema.ByteArray
})

type Address = typeof AddressSchema.Type
// {
//   payment_credential: Uint8Array
//   stake_credential: Uint8Array
// }

const Codec = Core.Data.withSchema(AddressSchema)

const addr: Address = {
  payment_credential: Core.Bytes.fromHex("abc123def456abc123def456abc123def456abc123def456abc123de"),
  stake_credential: Core.Bytes.fromHex("def456abc123def456abc123def456abc123def456abc123def456ab")
}

const cbor = Codec.toCBORHex(addr)

import { Core } from "@evolution-sdk/evolution"

const CredentialSchema = Core.TSchema.Variant({
  VerificationKey: {
    hash: Core.TSchema.ByteArray
  },
  Script: {
    hash: Core.TSchema.ByteArray
  }
})

type Credential = typeof CredentialSchema.Type
// | { VerificationKey: { hash: Uint8Array } }
// | { Script: { hash: Uint8Array } }

const Codec = Core.Data.withSchema(CredentialSchema)

// Verification key credential
const vkeyCred: Credential = {
  VerificationKey: {
    hash: Core.Bytes.fromHex("abc123def456abc123def456abc123def456abc123def456abc123de")
  }
}

// Script credential
const scriptCred: Credential = {
  Script: {
    hash: Core.Bytes.fromHex("def456abc123def456abc123def456abc123def456abc123def456ab")
  }
}

const cbor1 = Codec.toCBORHex(vkeyCred)
const cbor2 = Codec.toCBORHex(scriptCred)

import { Core } from "@evolution-sdk/evolution"

const IntListSchema = Core.TSchema.Array(Core.TSchema.Integer)

type IntList = typeof IntListSchema.Type
// ReadonlyArray<bigint>

const Codec = Core.Data.withSchema(IntListSchema)

const amounts: IntList = [100n, 200n, 300n]
const cbor = Codec.toCBORHex(amounts)

import { Core } from "@evolution-sdk/evolution"

const AssetsSchema = Core.TSchema.Map(
  Core.TSchema.ByteArray, // AssetName
  Core.TSchema.Integer    // Quantity
)

type Assets = typeof AssetsSchema.Type
// Map<Uint8Array, bigint>

const Codec = Core.Data.withSchema(AssetsSchema)

const assets: Assets = new Map([
  [Core.Bytes.fromHex("546f6b656e"), 100n], // "Token" in hex
  [Core.Bytes.fromHex("4e4654"), 1n]        // "NFT" in hex
])

const cbor = Codec.toCBORHex(assets)

import { Core } from "@evolution-sdk/evolution"

const PersonSchema = Core.TSchema.Struct({
  name: Core.TSchema.ByteArray,
  nickname: Core.TSchema.UndefinedOr(Core.TSchema.ByteArray)
})

type Person = typeof PersonSchema.Type
// {
//   name: Uint8Array
//   nickname: Uint8Array | undefined
// }

const Codec = Core.Data.withSchema(PersonSchema)

const person1: Person = {
  name: Core.Bytes.fromHex("416c696365"), // "Alice"
  nickname: undefined
}

const person2: Person = {
  name: Core.Bytes.fromHex("426f62"), // "Bob"
  nickname: Core.Bytes.fromHex("426f62627920") // "Bobby"
}

import { Core } from "@evolution-sdk/evolution"

const Schema = Core.TSchema.Struct({
  id: Core.TSchema.ByteArray,
  amount: Core.TSchema.Integer
})

const Codec = Core.Data.withSchema(Schema)

// Codec provides:
// - toData(value) → PlutusData
// - fromData(data) → value
// - toCBORHex(value) → string
// - toCBORBytes(value) → Uint8Array
// - fromCBORHex(hex) → value
// - fromCBORBytes(bytes) → value

import { Core } from "@evolution-sdk/evolution"

const PaymentCredentialSchema = Core.TSchema.Variant({
  VerificationKey: {
    hash: Core.TSchema.ByteArray
  },
  Script: {
    hash: Core.TSchema.ByteArray
  }
})

export type PaymentCredential = typeof PaymentCredentialSchema.Type

export const PaymentCredentialCodec = Core.Data.withSchema(PaymentCredentialSchema)

// Use in your app
const cred: PaymentCredential = {
  VerificationKey: {
    hash: Core.Bytes.fromHex("abc123def456abc123def456abc123def456abc123def456abc123de")
  }
}

const cbor = PaymentCredentialCodec.toCBORHex(cred)

import { Core } from "@evolution-sdk/evolution"

const EscrowDatumSchema = Core.TSchema.Struct({
  beneficiary: Core.TSchema.ByteArray,
  deadline: Core.TSchema.Integer,
  amount: Core.TSchema.Integer
})

export type EscrowDatum = typeof EscrowDatumSchema.Type

export const EscrowDatumCodec = Core.Data.withSchema(EscrowDatumSchema)

// Create datum
const datum: EscrowDatum = {
  beneficiary: Core.Bytes.fromHex("abc123def456abc123def456abc123def456abc123def456abc123de"),
  deadline: 1735689600000n,
  amount: 10000000n
}

// Encode for transaction
const datumCbor = EscrowDatumCodec.toCBORHex(datum)

import { Core } from "@evolution-sdk/evolution"

const RedeemerSchema = Core.TSchema.Variant({
  Claim: {},
  Cancel: {},
  Update: {
    new_beneficiary: Core.TSchema.ByteArray,
    new_deadline: Core.TSchema.Integer
  }
})

export type Redeemer = typeof RedeemerSchema.Type

export const RedeemerCodec = Core.Data.withSchema(RedeemerSchema)

// Different actions
const claim: Redeemer = { Claim: {} }
const cancel: Redeemer = { Cancel: {} }
const update: Redeemer = {
  Update: {
    new_beneficiary: Core.Bytes.fromHex("def456abc123def456abc123def456abc123def456abc123def456ab"),
    new_deadline: 1735776000000n
  }
}

const claimCbor = RedeemerCodec.toCBORHex(claim)

import { Core } from "@evolution-sdk/evolution"

// Base schemas
const CredentialSchema = Core.TSchema.Variant({
  VerificationKey: { hash: Core.TSchema.ByteArray },
  Script: { hash: Core.TSchema.ByteArray }
})

const StakeCredentialSchema = Core.TSchema.Variant({
  Inline: { credential: CredentialSchema },
  Pointer: {
    slot_number: Core.TSchema.Integer,
    transaction_index: Core.TSchema.Integer,
    certificate_index: Core.TSchema.Integer
  }
})

// Composed schema
const AddressSchema = Core.TSchema.Struct({
  payment_credential: CredentialSchema,
  stake_credential: Core.TSchema.UndefinedOr(StakeCredentialSchema)
})

export type Address = typeof AddressSchema.Type

export const AddressCodec = Core.Data.withSchema(AddressSchema)

import { Core } from "@evolution-sdk/evolution"

const Schema = Core.TSchema.Struct({
  id: Core.TSchema.ByteArray,
  amount: Core.TSchema.Integer,
  metadata: Core.TSchema.UndefinedOr(Core.TSchema.ByteArray)
})

// Extract type
type MyType = typeof Schema.Type
// {
//   id: Uint8Array
//   amount: bigint
//   metadata: Uint8Array | undefined
// }

// Use in functions
function process(data: MyType) {
  console.log("Processing amount:", data.amount)
}

import { Core } from "@evolution-sdk/evolution"

const MyDatumSchema = Core.TSchema.Struct({
  value: Core.TSchema.Integer
})

export type MyDatum = typeof MyDatumSchema.Type
export const MyDatumCodec = Core.Data.withSchema(MyDatumSchema)