import deepmerge from "deepmerge"
import { produce } from "immer"
import { useContext } from "react"
import { create, useStore } from "zustand"

import { REDEMPTION } from "@/constants/booking"
import { dt } from "@/lib/dt"

import { DetailsContext } from "@/contexts/Details"

import {
  add,
  calcTotalPrice,
  calculateCorporateChequePrice,
  calculateVoucherPrice,
  checkRoomProgress,
  extractGuestFromUser,
  findNextInvalidStep,
  getRoomPrice,
  getTotalPrice,
  handleStepProgression,
  writeToSessionStorage,
} from "./helpers"

import type { BreakfastPackages } from "@/types/components/hotelReservation/breakfast"
import type { Price } from "@/types/components/hotelReservation/price"
import { CurrencyEnum } from "@/types/enums/currency"
import { StepEnum } from "@/types/enums/step"
import type {
  DetailsState,
  InitialState,
  RoomState,
} from "@/types/stores/enter-details"
import type { SafeUser } from "@/types/user"

const defaultGuestState = {
  countryCode: "",
  dateOfBirth: "",
  email: "",
  firstName: "",
  join: false,
  lastName: "",
  membershipNo: "",
  phoneNumber: "",
  zipCode: "",
}

export const detailsStorageName = "rooms-details-storage"

export function createDetailsStore(
  initialState: InitialState,
  searchParams: string,
  user: SafeUser,
  breakfastPackages: BreakfastPackages | null
) {
  const isMember = !!user
  const isRedemption =
    new URLSearchParams(searchParams).get("searchtype") === REDEMPTION

  const isVoucher = initialState.rooms.some(
    (room) => "voucher" in room.roomRate
  )
  const isCorpChq = initialState.rooms.some(
    (room) => "corporateCheque" in room.roomRate
  )

  let initialTotalPrice: Price
  const roomOneRoomRate = initialState.rooms[0].roomRate
  if (isRedemption && "redemption" in roomOneRoomRate) {
    initialTotalPrice = {
      local: {
        currency: CurrencyEnum.POINTS,
        price: roomOneRoomRate.redemption.localPrice.pointsPerStay,
      },
    }
    if (roomOneRoomRate.redemption.localPrice.currency) {
      initialTotalPrice.local.additionalPriceCurrency =
        roomOneRoomRate.redemption.localPrice.currency
    }
    if (roomOneRoomRate.redemption.localPrice.additionalPricePerStay) {
      initialTotalPrice.local.additionalPrice =
        roomOneRoomRate.redemption.localPrice.additionalPricePerStay
    }
  } else if (isVoucher) {
    initialTotalPrice = calculateVoucherPrice(
      initialState.rooms.map((r) => r.roomRate)
    )
  } else if (isCorpChq) {
    initialTotalPrice = calculateCorporateChequePrice(
      initialState.rooms.map((r) => r.roomRate)
    )
  } else {
    initialTotalPrice = getTotalPrice(
      initialState.rooms.map((r) => r.roomRate),
      isMember
    )
  }

  initialState.rooms.forEach((room) => {
    if (room.roomFeatures) {
      room.roomFeatures.forEach((pkg) => {
        if (initialTotalPrice.requested) {
          initialTotalPrice.requested.price = add(
            initialTotalPrice.requested.price,
            pkg.requestedPrice.totalPrice
          )
        }
        initialTotalPrice.local.price = add(
          initialTotalPrice.local.price,
          pkg.localPrice.totalPrice
        )
      })
    }
  })

  return create<DetailsState>()((set) => ({
    activeRoom: 0,
    booking: initialState.booking,
    breakfastPackages,
    canProceedToPayment: false,
    isSubmittingDisabled: false,
    isSummaryOpen: false,
    lastRoom: initialState.booking.rooms.length - 1,
    rooms: initialState.rooms.map((room, idx) => {
      const steps: RoomState["steps"] = {
        [StepEnum.selectBed]: {
          step: StepEnum.selectBed,
          isValid: !!room.bedType,
        },
        [StepEnum.breakfast]: {
          step: StepEnum.breakfast,
          isValid: false,
        },
        [StepEnum.details]: {
          step: StepEnum.details,
          isValid: false,
        },
      }

      if (room.breakfastIncluded || !breakfastPackages?.length) {
        delete steps[StepEnum.breakfast]
      }

      const currentStep =
        Object.values(steps).find((step) => !step.isValid)?.step ??
        StepEnum.selectBed

      return {
        actions: {
          setStep(step) {
            return set(
              produce((state: DetailsState) => {
                const isSameRoom = idx === state.activeRoom
                const room = state.rooms[idx]
                if (isSameRoom) {
                  // Closed same accordion as was open
                  if (step === room.currentStep) {
                    if (room.isComplete) {
                      // Room is complete, move to next room or payment
                      const nextRoomIdx = state.rooms.findIndex(
                        (r) => !r.isComplete
                      )
                      state.activeRoom = nextRoomIdx
                      // Done, proceed to payment
                      if (nextRoomIdx === -1) {
                        room.currentStep = null
                      } else {
                        const nextRoom = state.rooms[nextRoomIdx]
                        const nextInvalidStep = findNextInvalidStep(nextRoom)
                        nextRoom.currentStep = nextInvalidStep
                      }
                    } else {
                      room.currentStep = findNextInvalidStep(room)
                    }
                  } else {
                    if (room.steps[step]?.isValid) {
                      room.currentStep = step
                    } else {
                      room.currentStep = findNextInvalidStep(room)
                    }
                  }
                } else {
                  const arePreviousRoomsCompleted = state.rooms
                    .slice(0, idx)
                    .every((room) => room.isComplete)
                  if (arePreviousRoomsCompleted) {
                    state.activeRoom = idx
                    if (room.steps[step]?.isValid) {
                      room.currentStep = step
                    } else {
                      room.currentStep = findNextInvalidStep(room)
                    }
                  } else {
                    const firstIncompleteRoom = state.rooms.findIndex(
                      (r) => !r.isComplete
                    )
                    state.activeRoom = firstIncompleteRoom
                    if (firstIncompleteRoom === -1) {
                      // All rooms are done, proceed to payment
                      room.currentStep = null
                    } else {
                      const nextRoom = state.rooms[firstIncompleteRoom]
                      nextRoom.currentStep = findNextInvalidStep(nextRoom)
                    }
                  }
                }
              })
            )
          },
          updateBedType(bedType) {
            return set(
              produce((state: DetailsState) => {
                state.rooms[idx].steps[StepEnum.selectBed].isValid = true
                state.rooms[idx].room.bedType = bedType

                const isAllStepsCompleted = checkRoomProgress(
                  state.rooms[idx].steps
                )
                if (isAllStepsCompleted) {
                  state.rooms[idx].isComplete = true
                }

                handleStepProgression(state.rooms[idx], state)

                writeToSessionStorage({
                  activeRoom: state.activeRoom,
                  booking: state.booking,
                  rooms: state.rooms,
                })
              })
            )
          },
          updateBreakfast(breakfast) {
            return set(
              produce((state: DetailsState) => {
                const currentRoom = state.rooms[idx]
                if (currentRoom.steps[StepEnum.breakfast]) {
                  currentRoom.steps[StepEnum.breakfast].isValid = true
                }

                const currentTotalPriceRequested = state.totalPrice.requested
                let stateTotalRequestedPrice = 0
                if (currentTotalPriceRequested) {
                  stateTotalRequestedPrice =
                    currentTotalPriceRequested.price ?? 0
                }

                const stateTotalLocalPrice = state.totalPrice.local.price
                const stateTotalLocalRegularPrice =
                  state.totalPrice.local.regularPrice

                const addToTotalPrice =
                  (currentRoom.room.breakfast === undefined ||
                    currentRoom.room.breakfast === false) &&
                  !!breakfast

                const subtractFromTotalPrice =
                  currentRoom.room.breakfast && breakfast === false

                const nights = dt(state.booking.toDate).diff(
                  state.booking.fromDate,
                  "days"
                )

                if (addToTotalPrice) {
                  const breakfastTotalRequestedPrice =
                    breakfast.requestedPrice.price *
                    currentRoom.room.adults *
                    nights
                  const breakfastTotalPrice =
                    breakfast.localPrice.price *
                    currentRoom.room.adults *
                    nights
                  state.totalPrice = {
                    requested: state.totalPrice.requested && {
                      currency: state.totalPrice.requested.currency,
                      price:
                        stateTotalRequestedPrice + breakfastTotalRequestedPrice,
                    },
                    local: {
                      currency: breakfast.localPrice.currency,
                      price: stateTotalLocalPrice ?? 0 + breakfastTotalPrice,
                      regularPrice: stateTotalLocalRegularPrice
                        ? stateTotalLocalRegularPrice + breakfastTotalPrice
                        : undefined,
                    },
                  }
                }

                if (subtractFromTotalPrice) {
                  let currency = state.totalPrice.local.currency
                  let currentBreakfastTotalPrice = 0
                  let currentBreakfastTotalRequestedPrice = 0
                  if (currentRoom.room.breakfast) {
                    currentBreakfastTotalPrice =
                      currentRoom.room.breakfast.localPrice.price *
                      currentRoom.room.adults *
                      nights
                    currentBreakfastTotalRequestedPrice =
                      currentRoom.room.breakfast.requestedPrice.totalPrice *
                      currentRoom.room.adults *
                      nights
                    currency = currentRoom.room.breakfast.localPrice.currency
                  }

                  let requestedPrice =
                    stateTotalRequestedPrice -
                    currentBreakfastTotalRequestedPrice
                  if (requestedPrice < 0) {
                    requestedPrice = 0
                  }
                  let localPrice =
                    stateTotalLocalPrice - currentBreakfastTotalPrice
                  if (localPrice < 0) {
                    localPrice = 0
                  }
                  let regularPrice = stateTotalLocalRegularPrice
                    ? stateTotalLocalRegularPrice - currentBreakfastTotalPrice
                    : undefined

                  state.totalPrice = {
                    requested: state.totalPrice.requested && {
                      currency: state.totalPrice.requested.currency,
                      price: requestedPrice,
                    },
                    local: {
                      currency,
                      price: localPrice,
                      regularPrice,
                    },
                  }
                }

                currentRoom.room.breakfast = breakfast

                const isAllStepsCompleted = checkRoomProgress(
                  state.rooms[idx].steps
                )
                if (isAllStepsCompleted) {
                  state.rooms[idx].isComplete = true
                }

                handleStepProgression(currentRoom, state)

                writeToSessionStorage({
                  activeRoom: state.activeRoom,
                  booking: state.booking,
                  rooms: state.rooms,
                })
              })
            )
          },
          updateDetails(data) {
            return set(
              produce((state: DetailsState) => {
                state.rooms[idx].steps[StepEnum.details].isValid = true
                const currentRoom = state.rooms[idx].room

                currentRoom.guest.countryCode = data.countryCode
                currentRoom.guest.email = data.email
                currentRoom.guest.firstName = data.firstName
                currentRoom.guest.join = data.join
                currentRoom.guest.lastName = data.lastName

                if (data.specialRequest?.comment) {
                  currentRoom.specialRequest.comment =
                    data.specialRequest.comment
                }

                if (data.join) {
                  currentRoom.guest.membershipNo = undefined
                } else {
                  currentRoom.guest.membershipNo = data.membershipNo
                }
                currentRoom.guest.phoneNumber = data.phoneNumber

                // Only valid for room 1
                if (idx === 0 && data.join && !isMember) {
                  if ("dateOfBirth" in currentRoom.guest) {
                    currentRoom.guest.dateOfBirth = data.dateOfBirth
                  }
                  if ("zipCode" in currentRoom.guest) {
                    currentRoom.guest.zipCode = data.zipCode
                  }
                }

                currentRoom.roomPrice = getRoomPrice(
                  currentRoom.roomRate,
                  Boolean(data.join || data.membershipNo || isMember)
                )

                const nights = dt(state.booking.toDate).diff(
                  state.booking.fromDate,
                  "days"
                )

                state.totalPrice = calcTotalPrice(
                  state.rooms,
                  state.totalPrice.local.currency,
                  isMember,
                  nights
                )

                const isAllStepsCompleted = checkRoomProgress(
                  state.rooms[idx].steps
                )
                if (isAllStepsCompleted) {
                  state.rooms[idx].isComplete = true
                }

                handleStepProgression(state.rooms[idx], state)

                writeToSessionStorage({
                  activeRoom: state.activeRoom,
                  booking: state.booking,
                  rooms: state.rooms,
                })
              })
            )
          },
          updateMultiroomDetails(data) {
            return set(
              produce((state: DetailsState) => {
                state.rooms[idx].steps[StepEnum.details].isValid = true

                state.rooms[idx].room.guest.countryCode = data.countryCode
                state.rooms[idx].room.guest.email = data.email
                state.rooms[idx].room.guest.firstName = data.firstName
                state.rooms[idx].room.guest.join = data.join
                state.rooms[idx].room.guest.lastName = data.lastName

                if (data.join) {
                  state.rooms[idx].room.guest.membershipNo = undefined
                } else {
                  state.rooms[idx].room.guest.membershipNo = data.membershipNo
                }
                state.rooms[idx].room.guest.phoneNumber = data.phoneNumber

                const getMemberPrice = Boolean(data.join || data.membershipNo)
                state.rooms[idx].room.roomPrice = getRoomPrice(
                  state.rooms[idx].room.roomRate,
                  getMemberPrice
                )

                const nights = dt(state.booking.toDate).diff(
                  state.booking.fromDate,
                  "days"
                )

                state.totalPrice = calcTotalPrice(
                  state.rooms,
                  state.totalPrice.local.currency,
                  getMemberPrice,
                  nights
                )

                const isAllStepsCompleted = checkRoomProgress(
                  state.rooms[idx].steps
                )
                if (isAllStepsCompleted) {
                  state.rooms[idx].isComplete = true
                }

                handleStepProgression(state.rooms[idx], state)

                writeToSessionStorage({
                  activeRoom: state.activeRoom,
                  booking: state.booking,
                  rooms: state.rooms,
                })
              })
            )
          },
        },
        room: {
          ...room,
          adults: initialState.booking.rooms[idx].adults,
          childrenInRoom: initialState.booking.rooms[idx].childrenInRoom,
          bedType: room.bedType,
          breakfast:
            !breakfastPackages?.length || room.breakfastIncluded
              ? false
              : undefined,
          guest:
            isMember && idx === 0
              ? deepmerge(defaultGuestState, extractGuestFromUser(user))
              : defaultGuestState,
          roomPrice: getRoomPrice(room.roomRate, isMember && idx === 0),
          specialRequest: {
            comment: "",
          },
        },

        currentStep,
        isComplete: false,
        steps,
      }
    }),
    searchParamString: searchParams,
    totalPrice: initialTotalPrice,
    vat: initialState.vat,

    actions: {
      setIsSubmittingDisabled(isSubmittingDisabled) {
        return set(
          produce((state: DetailsState) => {
            state.isSubmittingDisabled = isSubmittingDisabled
          })
        )
      },
      setTotalPrice(totalPrice) {
        return set(
          produce((state: DetailsState) => {
            state.totalPrice.requested = totalPrice.requested
            state.totalPrice.local = totalPrice.local
          })
        )
      },
      toggleSummaryOpen() {
        return set(
          produce((state: DetailsState) => {
            state.isSummaryOpen = !state.isSummaryOpen
          })
        )
      },
      updateSeachParamString(searchParamString) {
        return set(
          produce((state: DetailsState) => {
            state.searchParamString = searchParamString
          })
        )
      },
    },
  }))
}

export function useEnterDetailsStore<T>(selector: (store: DetailsState) => T) {
  const store = useContext(DetailsContext)

  if (!store) {
    throw new Error("useEnterDetailsStore must be used within DetailsProvider")
  }

  return useStore(store, selector)
}