async function createEvent(totalSeats: number) {
  const eventId = `evt-${randomUUID()}`
  await redisClient.set(`event:${eventId}:totalSeats`, totalSeats)
  return { eventId }
}

async function holdSeat(eventId: string, seatIndex: number, userId: string) {
  const seatKey = `seat:${eventId}:${seatIndex}`
  const existing = await redisClient.get(seatKey)
  if (existing) throw new Error("Seat is already held or reserved")
  await redisClient.set(seatKey, userId)
  await redisClient.expire(seatKey, 60)
}

async function reserveSeat(eventId: string, seatIndex: number, userId: string) {
  const seatKey = `seat:${eventId}:${seatIndex}`
  const holder = await redisClient.get(seatKey)
  if (holder !== userId) throw new Error("Seat is not held by user")
  await redisClient.set(seatKey, userId) // SET with no TTL clears the earlier EXPIRE — permanent
}

async function getAvailableSeats(eventId: string) {
  const totalSeats = Number(await redisClient.get(`event:${eventId}:totalSeats`))
  const available: number[] = []
  for (let seatIndex = 1; seatIndex <= totalSeats; seatIndex++) {
    const holder = await redisClient.get(`seat:${eventId}:${seatIndex}`)
    if (!holder) available.push(seatIndex)
  }
  return available
}

const holdSeat = async (eventId: EventId, userId: UserId, seatIndex: SeatNumber, holdSeatExpiration?:HoldSeatExpiration|undefined) => {
    holdSeatExpiration = HoldSeatExpiration.parse(holdSeatExpiration);
    const seatKey = seatIndex.toString()
    const hashKey = eventId+":seats"
    await getEvent(eventId);
    /* there are 3 possible way to limit a user to have n max seats.
      1. use a separate hash per user -> this is more performante but it will require more memory
      2. inside the transation, count the keys that have the user id value -> this is the more correct, but the less performant (the transaction will block the hash for more time)
      3. do like the point 2, but before the transaction -> this is the middle ground, is not an issue give that the hash can have no more then 1000 keys, also in some edge case the user could be able to require more then n seat, but I thing is the best trade off in this case
    */

    const hash = await redisClient.hGetAll(hashKey);
    const userSeatsCount = Object.values(hash).filter(value => value === userId).length;

    if((userSeatsCount+1) > props.userMaxSeats){
        throw new Error("User has already the maximum number of seats")
    }


    const transaction = redisClient.multi();
    transaction.hSetNX(hashKey, seatKey, userId);
    transaction.hExpire(hashKey,seatKey, holdSeatExpiration, "NX");
    const transactionResult =  await transaction.exec();
    const holdResult =  transactionResult[0];
    if(!holdResult)
        throw new Error("Seat is already held")
}

const refreshHoldSeat = async (eventId: EventId, userId: UserId, seatIndex: SeatNumber, holdSeatExpiration?:HoldSeatExpiration|undefined) => {
    holdSeatExpiration = HoldSeatExpiration.parse(holdSeatExpiration);
    const seatKey = seatIndex.toString()
    const hashKey = eventId+":seats"
    const holdSeat = await redisClient.hGet(hashKey, seatKey);
    if(typeof holdSeat !== "string" ||holdSeat !== userId){
        throw new Error("Seat is not held by user")
    }

    const [expireResult] = await redisClient.hExpire(hashKey,seatKey, holdSeatExpiration, "GT");
    if(expireResult === 0){
        throw new Error("Seat has already expired")
    }
}

const reserveSeat = async (eventId: EventId, userId: UserId, seatIndex:SeatNumber) => {
    const seatKey = seatIndex.toString()
    const hashKey = eventId+":seats"
    const holdSeat = await redisClient.hGet(hashKey, seatKey);
    if(typeof holdSeat !== "string" ||holdSeat !== userId){
        throw new Error("Seat is not held by user")
    }
    await redisClient.hExpire(hashKey,seatKey, HOLD_SEAT_EXPIRATION_DONOT_EXPIRE, "XX");
    // await redisClient.hPersist(hashKey, seatKey);

}

const getAvailableSeats = async (eventId: EventId): Promise<SeatNumber[]> => {
    const totalSeatsString = await redisClient.hGet(eventId, "totalSeats");
    const totalSeats = SeatCounter.parse(parseInt(totalSeatsString||""));
    const hashKey = eventId+":seats"
    const seatsNotAvailable = await redisClient.hKeys(hashKey);
    const potentialAvailableSeatch = Array.from({"length": totalSeats}, (_,i) => `${i+1}`)
    return potentialAvailableSeatch.filter(seat => !seatsNotAvailable.includes(seat)).map(seat => SeatNumber.parse(seat));

}

it('if userA hold a seat, userB hold attemp should fail', async () => {
  await reservationsClient.holdSeat(eventId, userAId, seatNumber)
  const secondHoldSeatPromise = reservationsClient.holdSeat(eventId, userBId, seatNumber)
  await expect(secondHoldSeatPromise).rejects.toThrow()
})

await reservationsClient.holdSeat(eventId, userAId, seatNumber, /* 1s */ seatHoldExpirationSeconds)
await reservationsClient.refreshHoldSeat(eventId, userAId, seatNumber, /* 3s */ seatRefreshHoldExpirationSeconds)

// userB tries to hold the same seat before the refreshed TTL — must still fail
const userBHoldFail = await reservationsClient.holdSeat(eventId, userBId, seatNumber, seatHoldExpirationSeconds)
  .catch(e => "userBHoldFail")
expect(userBHoldFail).toBe("userBHoldFail")

await reservationsClient.holdSeat(eventId, userAId, seatNumber, /* 10s */ seatHoldExpirationSeconds)
await reservationsClient.reserveSeat(eventId, userAId, seatNumber)

// userB tries to hold the now-reserved seat with a 1s TTL — fails
const fail = await reservationsClient.holdSeat(eventId, userBId, seatNumber, /* 1s */ seatHoldExpirationUserBSeconds)
  .catch(e => "userbfail")

// wait past userB's *would-be* TTL...
await sleep(seatHoldExpirationUserBSeconds + 1)

// ...the seat is still reserved by userA, not silently released
await expect(reservationsClient.getEventSeat(eventId, seatNumber)).resolves.toBe(userAId)