import { useMemo } from "react"

import {
  RoomPackageCodeEnum,
  type RoomPackageData,
} from "@/types/components/hotelReservation/selectRate/roomFilter"
import type {
  Rate,
  RateCode,
} from "@/types/components/hotelReservation/selectRate/selectRate"
import type { RoomConfiguration } from "@/server/routers/hotels/output"

interface UseRateSummary {
  searchedRoomsAndGuests: Array<{ adults: number; children?: any[] }>
  selectedRates: (RateCode | undefined)[]
  getFilteredRooms: (roomIndex: number) => RoomConfiguration[]
  selectedPackagesByRoom: Record<number, RoomPackageCodeEnum[]>
  availablePackages: RoomPackageData
  roomCategories: Array<{ name: string; roomTypes: Array<{ code: string }> }>
}

export function useRateSummary({
  searchedRoomsAndGuests,
  selectedRates,
  getFilteredRooms,
  selectedPackagesByRoom,
  availablePackages,
  roomCategories,
}: UseRateSummary) {
  return useMemo(() => {
    const summaries: (Rate | null)[] = []

    searchedRoomsAndGuests.forEach((_, roomIndex) => {
      const selectedRate = selectedRates[roomIndex]
      const filteredRooms = getFilteredRooms(roomIndex)
      const selectedPackages = selectedPackagesByRoom[roomIndex] || []

      const room = filteredRooms.find(
        (room) => room.roomTypeCode === selectedRate?.roomTypeCode
      )

      if (!room) {
        summaries[roomIndex] = null
        return
      }

      const product = room.products.find(
        (product) =>
          product.productType.public.rateCode === selectedRate?.publicRateCode
      )

      if (!product) {
        summaries[roomIndex] = null
        return
      }

      const petRoomPackage =
        (selectedPackages.includes(RoomPackageCodeEnum.PET_ROOM) &&
          availablePackages.find(
            (pkg) => pkg.code === RoomPackageCodeEnum.PET_ROOM
          )) ||
        undefined

      const features = filteredRooms.find((room) =>
        room.features.some(
          (feature) => feature.code === RoomPackageCodeEnum.PET_ROOM
        )
      )?.features

      const roomType = roomCategories.find((roomCategory) =>
        roomCategory.roomTypes.some(
          (roomType) => roomType.code === room.roomTypeCode
        )
      )

      summaries[roomIndex] = {
        features: petRoomPackage && features ? features : [],
        priceName: selectedRate?.name,
        priceTerm: selectedRate?.paymentTerm,
        public: product.productType.public,
        member: product.productType.member,
        roomType: roomType?.name || room.roomType,
        roomTypeCode: room.roomTypeCode,
      }
    })

    return summaries
  }, [
    searchedRoomsAndGuests,
    selectedRates,
    getFilteredRooms,
    selectedPackagesByRoom,
    availablePackages,
    roomCategories,
  ])
}