// Límite del tipo number
const bigNumber = 30000000000000000
console.log(bigNumber) // 30000000000000000

// Si le sumaramos 1 a este número, el resultado debería ser:
// 30000000000000001

// Pero si lo intentas sumar con JS, el resultado es diferente:
console.log(bigNumber + 1) // 30000000000000000
console.log(bigNumber + 2) // 30000000000000000 (¡igual!)

// Incluso con números grandes, puedes perder precisión
let numeroGrande = 1234567890123456789
console.log(numeroGrande) // 1234567890123456800 (¡redondeado!)

// Con BigInt mantenemos la precisión
let numeroGrandeBigInt = 1234567890123456789n
console.log(numeroGrandeBigInt) // 1234567890123456789n (¡exacto!)
console.log(numeroGrandeBigInt + 1n) // 1234567890123456790n (¡exacto!)

// Enteros con sufijo 'n'
let grande1 = 123n
let grande2 = 9007199254740991n
let grande3 = 1234567890123456789012345678901234567890n

console.log(typeof grande1) // "bigint"

// Desde número (si está en rango seguro)
let desdeEntero = BigInt(123) // 123n
let desdeEnteroGrande = BigInt(9007199254740991) // 9007199254740991n

// Desde string
let desdeString = BigInt('123456789012345678901234567890')
// 123456789012345678901234567890n

// Desde string hexadecimal
let desdeHex = BigInt('0x1fffffffffffff') // 9007199254740991n

// Desde string binaria
let desdeBin = BigInt('0b11111111111111111111111111111111')

// Desde una variable
let numeroGrandeEnString = '123456789012345678901234567890'
let desdeVariable = BigInt(numeroGrandeEnString) // 123456789012345678901234567890n

// ❌ No funciona con decimales
// BigInt(3.14) // RangeError: The number 3.14 cannot be converted to a BigInt

// ❌ No funciona con números que ya están fuera del rango seguro de Number
// BigInt(Number.MAX_SAFE_INTEGER + 1) // Puede dar resultados inesperados

// ❌ No funciona con strings inválidos
// BigInt("abc") // SyntaxError: Cannot convert abc to a BigInt

let a = 100n
let b = 200n

// Operaciones básicas
console.log(a + b) // 300n
console.log(a - b) // -100n
console.log(a * b) // 20000n
console.log(b / a) // 2n (división entera)
console.log(b % a) // 0n (módulo)
console.log(a ** 2n) // 10000n (exponenciación)

// ¡Ojo! La división siempre es entera, no te da los decimales
console.log(7n / 2n) // 3n (no 3.5)
console.log(10n / 3n) // 3n (no 3.333...)

let x = 100n
let y = 200n

// Comparaciones funcionan normalmente
console.log(x < y) // true
console.log(x > y) // false
console.log(x === 100n) // true
console.log(x !== y) // true

// Comparación con números regulares
console.log(100n == 100) // true (coerción)
console.log(100n === 100) // false (tipos diferentes)
console.log(100n < 101) // true
console.log(100n > 99) // true

let bits1 = 0b1010n // 10n
let bits2 = 0b1100n // 12n

// Operadores bitwise
console.log(bits1 & bits2) // 8n (AND)
console.log(bits1 | bits2) // 14n (OR)
console.log(bits1 ^ bits2) // 6n (XOR)
console.log(~bits1) // -11n (NOT)
console.log(bits1 << 2n) // 40n (shift left)
console.log(bits1 >> 1n) // 5n (shift right)

let bigint = 100n
let number = 50

// ❌ Esto no funciona
// console.log(bigint + number) // TypeError: Cannot mix BigInt and other types

// ✅ Hay que convertir explícitamente
console.log(bigint + BigInt(number)) // 150n
console.log(Number(bigint) + number) // 150

// ✅ O usar comparaciones que permiten coerción
console.log(bigint > number) // true

let grande = 100n

// ❌ Math no acepta BigInt
// Math.sqrt(grande) // TypeError: Cannot convert a BigInt value to a number
// Math.max(10n, 20n) // TypeError

// ✅ Usa operaciones nativas de BigInt
console.log(grande ** 2n) // 10000n para potencias

let objeto = {
  numero: 42,
  grande: 123n
}

// ❌ JSON.stringify no maneja BigInt
// JSON.stringify(objeto) // TypeError: Do not know how to serialize a BigInt

// ✅ Solución: convertir a string
let objetoSerializable = {
  numero: objeto.numero,
  grande: objeto.grande.toString()
}

console.log(JSON.stringify(objetoSerializable))
// {"numero":42,"grande":"123"}

// BigInt.asIntN() - convierte a entero con signo de N bits
console.log(BigInt.asIntN(8, 300n)) // 44n (300 en 8 bits con signo)

// BigInt.asUintN() - convierte a entero sin signo de N bits
console.log(BigInt.asUintN(8, 300n)) // 44n (300 en 8 bits sin signo)
console.log(BigInt.asUintN(8, -1n)) // 255n (-1 en 8 bits sin signo)

let grande = 123456789n

// A Number (cuidado con la precisión)
let comoNumber = Number(grande) // 123456789
console.log(typeof comoNumber) // "number"

// A String
let comoString = String(grande) // "123456789"
let comoStringDirect = grande.toString() // "123456789"

// A Boolean
let comoBoolean = Boolean(grande) // true
console.log(Boolean(0n)) // false

// Desde Number (solo enteros en rango seguro)
let desdeNumber = BigInt(42) // 42n

// Desde String
let desdeString = BigInt('123456789012345678901234567890')

// Desde Boolean
let desdeTrue = BigInt(true) // 1n
let desdeFalse = BigInt(false) // 0n