import { z } from 'zod'

export type HttpClientType = 'axios' | 'ofetch'

export const bookSchema = z.object({
  duration: z.number(),
  email: z.string().email(),
  firstName: z.string(),
  formFields: z.optional(
    z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
  ),
  guestEmails: z.optional(z.string().array()),
  lastName: z.string(),
  likelyAvailableUserIds: z.optional(z.string().array()),
  slug: z.string(),
  startTime: z.number(),
  timezone: z.string().default('Europe/Paris'),
})

export type CreateBooking<
  CustomFormValues extends Record<string, string | number | boolean> = Record<
    string,
    string | number | boolean
  >,
> = Omit<typeof bookSchema._type, 'formFields'> & {
  formFields: CustomFormValues
}

export type HubspotMeeting = {
  id: string
  slug: string
  link: string
  name: string
  type: 'ROUND_ROBIN_CALENDAR' | 'PERSONAL_LINK' | 'GROUP_CALENDAR'
  organizerUserId: string
  userIdsOfLinkMembers: string[]
  defaultLink: boolean
  createdAt: string
  updatedAt: string
}

export type HubspotMeetingLink = {
  linkId: string
  isOffline: boolean
  customParams: {
    legalConsentEnabled: boolean
    ownerPrioritized: boolean
    legalConsentOptions: {
      legitimateInterestSubscriptionTypes: number[]
      communicationConsentCheckboxes: {
        communicationTypeId: string
        label: string
        required: boolean
      }[]
      legitimateInterestLegalBasis: string
      communicationConsentText: string
      processingConsentType: string
      processingConsentText: string
      processingConsentCheckboxLabel: string
      processingConsentFooterText: string
      privacyPolicyText: string
      isLegitimateInterest: boolean
    }
    formFields: CustomFormField[]
    displayInfo: {
      avatar: string
      companyAvatar: string
      publicDisplayAvatarOption: string
    }
    guestSettings: {
      canAddGuests: boolean
      maxGuestCount: number
    }
    meetingBufferTime: number
    availability: {
      FRIDAY: OneDay[]
      MONDAY: OneDay[]
      THURSDAY: OneDay[]
      TUESDAY: OneDay[]
      WEDNESDAY: OneDay[]
    }
    startTimeIncrementMinutes: string
    weeksToAdvertise: number
    durations: number[]
    location: string
    welcomeScreenInfo: {
      useCompanyLogo: boolean
      showWelcomeScreen: boolean
    }
  }
  linkType: string
  allUsersBusyTimes: HubspotBusyTime[]
  brandingMetadata: Record<string, unknown>
  linkAvailability: HubspotLinkAvailability
}

export type HubspotMeetingAvailabilities = Pick<
  HubspotMeetingLink,
  'allUsersBusyTimes' | 'linkAvailability'
>

export type HubspotMeetingBookSuccess = {
  calendarEventId: string
  start: string
  duration: number
  contactId: string
  bookingTimezone: string
  locale: string
  legalConsentResponses: Array<unknown>
  formFields: {
    name: string
    label: string
    value: string
    isCustom: boolean
    fieldType: string
  }[]
  guestEmails: Array<string>
  subject: string
  location: string
  webConferenceMeetingId: string
  webConferenceUrl: string
  isOffline: boolean
  end: string
}

export type CustomFormField = {
  name: string
  label: string
  fieldType:
    | 'phonenumber'
    | 'textarea'
    | 'text'
    | 'date'
    | 'file'
    | 'number'
    | 'select'
    | 'radio'
    | 'checkbox'
    | 'booleancheckbox'
  type: 'string' | 'number' | 'date' | 'datetime' | 'enumeration'
  isCustom: boolean
  isRequired: boolean
}

type HubspotBusyTime = {
  isOffline: boolean
  meetingsUser: {
    id: string
    userId: string
    isSalesStarter: boolean
    userProfile: {
      firstName: string
      lastName: string
      email: string
      fullName: string
    }
    calendarProvider: string
  }
  busyTimes: {
    start: number
    end: number
  }[]
}

type OneDay = {
  start: number
  end: number
}

export const AvailabilitySchema = z.object({
  linkAvailability: z.object({
    hasMore: z.boolean(),
    linkAvailabilityByDuration: z.record(
      z.string(), // Key is a string like "900000"
      z.object({
        meetingDurationMillis: z.number().int(),
        availabilities: z.array(
          z.object({
            startMillisUtc: z.number().int(),
            endMillisUtc: z.number().int(),
          }),
        ),
      }),
    ),
  }),
  allUsersBusyTimes: z.array(
    z.object({
      isOffline: z.boolean(),
      meetingsUser: z.object({
        id: z.string(),
        userId: z.string(),
        isSalesStarter: z.boolean(),
        userProfile: z.object({
          firstName: z.string(),
          lastName: z.string(),
          email: z.string(),
          fullName: z.string(),
        }),
        calendarProvider: z.string(),
      }),
      busyTimes: z.array(
        z.object({
          start: z.number().int(),
          end: z.number().int(),
        }),
      ),
    }),
  ),
})

export type HubspotLinkAvailabilityResponse = z.infer<typeof AvailabilitySchema>

export type HubspotLinkAvailability = {
  linkAvailabilityByDuration: Record<
    string,
    {
      meetingDurationMillis: number
      availabilities: {
        startMillisUtc: number
        endMillisUtc: number
      }[]
    }
  >
  hasMore: boolean
}