'use client'

import { useEffect, useState } from 'react'
import axios from 'axios'
import { yupResolver } from '@hookform/resolvers/yup'
import { useForm } from 'react-hook-form'
import * as yup from 'yup'
import { toast } from 'react-toastify'
import {
  Alert,
  Button,
  HelperText,
  Label,
  Modal,
  ModalBody,
  ModalHeader,
  Spinner,
  TextInput,
} from 'flowbite-react'
import { FiClock } from 'react-icons/fi'

import buttonTheme from '@/lib/themes/button'
import formTheme from '@/lib/themes/form'
import modalTheme from '@/lib/themes/modal'
import { formatToMYT } from '@/lib/utils/date'

interface FollowUpTarget extends Followable {
  id: number
}

interface FollowUpModalProps {
  target: FollowUpTarget
  isOpen: boolean
  onClose: () => void
  onCompleted: (followUp: FollowUp) => void
  submitFollowUp: (
    evidenceUrl: string,
  ) => Promise<{ message: string; data: FollowUp }>
}

interface ApiErrorResponse {
  message?: string
  errors?: Record<string, string[]>
}

const followUpFormSchema = yup.object({
  evidence_url: yup
    .string()
    .trim()
    .required('Evidence URL is required')
    .matches(/^https:\/\//i, 'The evidence URL must use HTTPS')
    .url('Please enter a valid URL')
    .test(
      'is-google-drive-link',
      'The evidence URL must be a Google Drive link',
      (value) => {
        if (!value) return false

        try {
          const hostname = new URL(value).hostname.toLowerCase()

          return (
            hostname === 'drive.google.com' || hostname === 'docs.google.com'
          )
        } catch {
          return false
        }
      },
    ),
})

type FollowUpFormValues = yup.InferType<typeof followUpFormSchema>

function getAvailableAtTimestamp(value?: string) {
  if (!value) return null

  let dateString = value.trim()
  const looksLikeDateTime = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}/.test(
    dateString,
  )
  const hasTimezone = /([Zz]|[+-]\d{2}:?\d{2})$/.test(dateString)

  if (looksLikeDateTime && !hasTimezone) {
    dateString = dateString.replace(' ', 'T') + 'Z'
  }

  const timestamp = new Date(dateString).getTime()

  return Number.isNaN(timestamp) ? null : timestamp
}

function getRemainingSeconds(target: FollowUpTarget) {
  const availableAtTimestamp = getAvailableAtTimestamp(
    target.follow_up_available_at,
  )

  if (availableAtTimestamp !== null) {
    return Math.max(0, Math.ceil((availableAtTimestamp - Date.now()) / 1000))
  }

  return Math.max(0, target.follow_up_remaining_seconds ?? 0)
}

function formatCountdown(totalSeconds: number) {
  const seconds = Math.max(0, totalSeconds)
  const hours = Math.floor(seconds / 3600)
  const minutes = Math.floor((seconds % 3600) / 60)
  const remainingSeconds = seconds % 60

  const paddedMinutes = minutes.toString().padStart(2, '0')
  const paddedSeconds = remainingSeconds.toString().padStart(2, '0')

  if (hours > 0) {
    return `${hours}h ${paddedMinutes}m ${paddedSeconds}s`
  }

  return `${paddedMinutes}m ${paddedSeconds}s`
}

export default function FollowUpModal({
  target,
  isOpen,
  onClose,
  onCompleted,
  submitFollowUp,
}: FollowUpModalProps) {
  const [remainingSeconds, setRemainingSeconds] = useState(() =>
    getRemainingSeconds(target),
  )

  const isWaitingPeriod = target.follow_up_status?.label === 'Waiting Period'
  const showForm = target.can_be_followed_up || remainingSeconds === 0

  const {
    register,
    handleSubmit,
    reset,
    clearErrors,
    setError,
    formState: { errors, isSubmitting },
  } = useForm<FollowUpFormValues>({
    resolver: yupResolver(followUpFormSchema),
    defaultValues: {
      evidence_url: '',
    },
  })

  useEffect(() => {
    if (!isOpen) return

    const initialRemainingSeconds = getRemainingSeconds(target)
    const availableAtTimestamp =
      getAvailableAtTimestamp(target.follow_up_available_at) ??
      Date.now() + initialRemainingSeconds * 1000

    setRemainingSeconds(initialRemainingSeconds)
    reset()
    clearErrors()

    if (initialRemainingSeconds === 0) return

    const targetTimestamp = availableAtTimestamp
    const intervalId = window.setInterval(() => {
      const nextRemainingSeconds = Math.max(
        0,
        Math.ceil((targetTimestamp - Date.now()) / 1000),
      )

      setRemainingSeconds(nextRemainingSeconds)

      if (nextRemainingSeconds === 0) {
        window.clearInterval(intervalId)
      }
    }, 1000)

    return () => window.clearInterval(intervalId)
  }, [isOpen, target, reset, clearErrors])

  function handleClose() {
    reset()
    clearErrors()
    onClose()
  }

  async function handleFormSubmit(values: FollowUpFormValues) {
    try {
      const evidenceUrl = values.evidence_url.trim()
      const response = await submitFollowUp(evidenceUrl)

      toast.success(
        response.message || 'Follow-up has been successfully recorded.',
      )

      onCompleted(response.data)
      handleClose()
    } catch (error) {
      if (axios.isAxiosError<ApiErrorResponse>(error)) {
        const evidenceUrlError = error.response?.data?.errors?.evidence_url?.[0]

        if (evidenceUrlError) {
          setError('evidence_url', {
            type: 'server',
            message: evidenceUrlError,
          })
          return
        }

        toast.error(
          error.response?.data?.message || 'Failed to record follow-up.',
        )
        return
      }

      toast.error('Failed to record follow-up.')
    }
  }

  return (
    <Modal
      dismissible
      position="center"
      theme={modalTheme.modal}
      show={isOpen}
      onClose={handleClose}
    >
      <ModalHeader>
        {showForm ? 'Record Follow Up' : 'Follow Up Available Soon'}
      </ModalHeader>

      <ModalBody>
        {showForm ? (
          <div>
            {isWaitingPeriod && remainingSeconds === 0 && (
              <Alert color="success" className="mb-5">
                The waiting period has ended. You can now submit the follow-up.
              </Alert>
            )}

            <p className="mb-5 text-sm font-medium text-slate-500">
              Provide the evidence link for this follow-up. The link must be an
              HTTPS Google Drive link.
            </p>

            <form
              className="flex flex-col gap-5"
              noValidate
              onSubmit={handleSubmit(handleFormSubmit)}
            >
              <div className="w-full">
                <div className="mb-2 block">
                  <Label htmlFor="evidence_url" theme={formTheme.label}>
                    Evidence URL
                  </Label>
                </div>

                <TextInput
                  id="evidence_url"
                  type="url"
                  placeholder="https://drive.google.com/..."
                  color={errors.evidence_url ? 'failure' : 'gray'}
                  theme={formTheme.textInput}
                  disabled={isSubmitting}
                  {...register('evidence_url')}
                />

                {errors.evidence_url ? (
                  <HelperText color="failure">
                    {errors.evidence_url.message}
                  </HelperText>
                ) : (
                  <HelperText>
                    Use a Google Drive link from drive.google.com or
                    docs.google.com.
                  </HelperText>
                )}
              </div>

              <div className="flex justify-end gap-3">
                <Button
                  type="button"
                  color="alternative"
                  theme={buttonTheme.button}
                  disabled={isSubmitting}
                  onClick={handleClose}
                >
                  Cancel
                </Button>

                <Button
                  type="submit"
                  color="green"
                  theme={buttonTheme.button}
                  disabled={isSubmitting}
                >
                  {isSubmitting ? (
                    <>
                      <Spinner size="sm" className="mr-2" />
                      Submitting...
                    </>
                  ) : (
                    'Submit Follow Up'
                  )}
                </Button>
              </div>
            </form>
          </div>
        ) : (
          <div className="text-center">
            <div className="mx-auto mb-5 flex h-16 w-16 items-center justify-center rounded-full bg-amber-100">
              <FiClock className="h-8 w-8 text-amber-600" />
            </div>

            <h3 className="text-lg font-semibold text-slate-900">
              Follow-up is not available yet
            </h3>
            <p className="mt-2 text-sm font-medium text-slate-500">
              You can record the follow-up once the waiting period ends.
            </p>

            <div className="my-6 rounded-xl border border-amber-200 bg-amber-50 p-5">
              <p className="text-xs font-semibold uppercase tracking-wide text-amber-700">
                Available in
              </p>
              <p className="mt-1 text-3xl font-bold tabular-nums text-amber-900">
                {formatCountdown(remainingSeconds)}
              </p>
              <p className="mt-3 text-sm font-medium text-amber-800">
                Available at{' '}
                {formatToMYT(
                  target.follow_up_available_at,
                  "MMMM dd, yyyy 'at' HH:mm",
                )}
              </p>
            </div>

            <Button
              color="alternative"
              theme={buttonTheme.button}
              onClick={handleClose}
            >
              Close
            </Button>
          </div>
        )}
      </ModalBody>
    </Modal>
  )
}
