import { z } from "zod"

import { transformedImageVaultAssetSchema } from "@scandic-hotels/common/utils/imageVault"
import { removeMultipleSlashes } from "@scandic-hotels/common/utils/url"

import { Country } from "../../../types/country"
import { DestinationCountryPageEnum } from "../../../types/destinationCountryPage"
import { discriminatedUnionArray } from "../../../utils/discriminatedUnion"
import {
  accordionRefsSchema,
  accordionSchema,
} from "../schemas/blocks/accordion"
import { contentRefsSchema, contentSchema } from "../schemas/blocks/content"
import {
  destinationFiltersRefsSchema,
  transformedDestinationFiltersSchema,
} from "../schemas/destinationFilters"
import { mapLocationSchema } from "../schemas/mapLocation"
import {
  linkRefsUnionSchema,
  linkUnionSchema,
  transformPageLink,
} from "../schemas/pageLinks"
import { systemSchema } from "../schemas/system"

import type { ImageVaultAsset } from "@scandic-hotels/common/utils/imageVault"

export const destinationCountryPageContent = z
  .object({
    __typename: z.literal(
      DestinationCountryPageEnum.ContentStack.blocks.Content
    ),
  })
  .merge(contentSchema)

export const destinationCountryPageAccordion = z
  .object({
    __typename: z.literal(
      DestinationCountryPageEnum.ContentStack.blocks.Accordion
    ),
  })
  .merge(accordionSchema)

export const blocksSchema = z.discriminatedUnion("__typename", [
  destinationCountryPageAccordion,
  destinationCountryPageContent,
])

export const destinationCountryPageSchema = z.object({
  destination_country_page: z.object({
    title: z.string(),
    destination_settings: z.object({
      country: z.nativeEnum(Country),
      location: mapLocationSchema,
    }),
    heading: z.string(),
    preamble: z.string(),
    experiences: z
      .object({
        destination_experiences: z.array(z.string()),
      })
      .transform(({ destination_experiences }) => destination_experiences),
    images: z
      .array(z.object({ image: transformedImageVaultAssetSchema }))
      .transform((images) =>
        images
          .map((image) => image.image)
          .filter((image): image is ImageVaultAsset => !!image)
      )
      .nullish(),
    has_sidepeek: z.boolean().default(false),
    sidepeek_button_text: z.string().nullish(),
    sidepeek_content: z
      .object({
        heading: z.string(),
        content: z
          .object({
            json: z.any(),
            embedded_itemsConnection: z.object({
              edges: z.array(
                z.object({
                  node: linkUnionSchema.transform((data) => {
                    const link = transformPageLink(data)
                    if (link) {
                      return link
                    }
                    return data
                  }),
                })
              ),
            }),
          })
          .nullish(),
      })
      .nullish(),
    blocks: discriminatedUnionArray(blocksSchema.options).nullable(),
    seo_filters: transformedDestinationFiltersSchema,
    system: systemSchema.merge(
      z.object({
        created_at: z.string(),
        updated_at: z.string(),
      })
    ),
  }),
  trackingProps: z.object({
    url: z.string(),
  }),
})

export const countryPageUrlsSchema = z
  .object({
    all_destination_country_page: z.object({
      items: z.array(
        z
          .object({
            url: z.string(),
            destination_settings: z.object({
              country: z.string(),
            }),
            system: systemSchema,
          })
          .transform((data) => {
            return {
              country: data.destination_settings.country,
              url: removeMultipleSlashes(`/${data.system.locale}/${data.url}`),
            }
          })
      ),
    }),
  })
  .transform(
    ({ all_destination_country_page }) => all_destination_country_page.items
  )

/** REFS */
const destinationCountryPageContentRefs = z
  .object({
    __typename: z.literal(
      DestinationCountryPageEnum.ContentStack.blocks.Content
    ),
  })
  .merge(contentRefsSchema)

const destinationCountryPageAccordionRefs = z
  .object({
    __typename: z.literal(
      DestinationCountryPageEnum.ContentStack.blocks.Accordion
    ),
  })
  .merge(accordionRefsSchema)

const blocksRefsSchema = z.discriminatedUnion("__typename", [
  destinationCountryPageAccordionRefs,
  destinationCountryPageContentRefs,
])
export const destinationCountryPageRefsSchema = z.object({
  destination_country_page: z.object({
    sidepeek_content: z
      .object({
        content: z
          .object({
            embedded_itemsConnection: z.object({
              edges: z.array(
                z.object({
                  node: linkRefsUnionSchema,
                })
              ),
            }),
          })
          .nullish(),
      })
      .nullish(),
    blocks: discriminatedUnionArray(blocksRefsSchema.options).nullable(),
    seo_filters: destinationFiltersRefsSchema,
    system: systemSchema,
  }),
})