import type { Route } from './+types'

import { PlusCircleIcon, PlusIcon } from 'lucide-react'
import { MeiliSearchFilterBuilder } from 'meilisearch-helper'
import { Suspense, useState } from 'react'
import { Await, Link, useSearchParams } from 'react-router'

import { DataTable, DataTableViewOptions } from '@/components/data-table'
import { RangeCalendarFilter } from '@/components/range-calendar-filter'
import { createSearch } from '@/lib/meili'

import { FacetedFilter } from '@repo/ui/components/faceted-filter'
import { SearchForm } from '@repo/ui/components/search-form'
import { Skeleton } from '@repo/ui/components/skeleton'
import { Button } from '@repo/ui/components/ui/button'
import { Kbd } from '@repo/ui/components/ui/kbd'
import {
  Select,
  SelectContent,
  SelectGroup,
  SelectItem,
  SelectTrigger,
  SelectValue
} from '@repo/ui/components/ui/select'
import { columns, type Enrollment } from './columns'
import { statuses } from './data'

export function meta({}: Route.MetaArgs) {
  return [{ title: 'Matrículas' }]
}

export async function loader({ params, context, request }: Route.LoaderArgs) {
  const { searchParams } = new URL(request.url)
  const { orgid } = params
  const query = searchParams.get('q') || ''
  const from = searchParams.get('from') || ''
  const to = searchParams.get('to') || ''
  const sort = searchParams.get('sort') || 'created_at:desc'
  const status = searchParams.getAll('status') || []
  const page = Number(searchParams.get('p')) + 1
  const hitsPerPage = Number(searchParams.get('perPage')) || 25

  let builder = new MeiliSearchFilterBuilder().where('org_id', '=', orgid)

  if (status.length) {
    builder = builder.where('status', 'in', status)
  }

  if (from && to) {
    const [field, from_] = from.split(':')
    builder = builder.where(field, 'between', [from_, to])
  }

  return {
    data: createSearch({
      index: 'betaeducacao-prod-enrollments',
      filter: builder.build(),
      sort: [sort],
      query,
      page,
      hitsPerPage,
      env: context.cloudflare.env
    })
  }
}

const formatted = new Intl.DateTimeFormat('en-CA', {
  year: 'numeric',
  month: '2-digit',
  day: '2-digit'
})

export default function Route({ loaderData: { data } }) {
  const [searchParams, setSearchParams] = useSearchParams()
  // const [rangeField, setRangeField] = useState<string>('created_at')
  const { rangeField, dateRange } = useRangeParams('created_at')

  return (
    <Suspense fallback={<Skeleton />}>
      <div className="space-y-0.5 mb-8">
        <h1 className="text-2xl font-bold tracking-tight">
          Gerenciar matrículas
        </h1>
        <p className="text-muted-foreground">
          Matricule colaboradores de forma rápida e acompanhe seu progresso.
        </p>
      </div>

      <Await resolve={data}>
        {({ hits, page, hitsPerPage, totalHits }) => {
          return (
            <DataTable
              sort={[{ id: 'created_at', desc: true }]}
              columns={columns}
              data={hits as Enrollment[]}
              pageIndex={page - 1}
              pageSize={hitsPerPage}
              rowCount={totalHits}
              hiddenColumn={[
                'completed_at',
                'started_at',
                'failed_at',
                'canceled_at'
              ]}
            >
              <div className="flex flex-col 2xl:flex-row gap-2.5 mb-2.5">
                <div className="w-full 2xl:w-1/3">
                  <SearchForm
                    defaultValue={searchParams.get('q') || ''}
                    placeholder={
                      <>
                        Digite <Kbd className="border font-mono">/</Kbd> para
                        pesquisar
                      </>
                    }
                    onChange={(value) =>
                      setSearchParams((searchParams) => {
                        searchParams.set('q', String(value))
                        searchParams.delete('p')
                        return searchParams
                      })
                    }
                  />
                </div>

                <div className="flex gap-2.5 max-lg:flex-col w-full">
                  <div className="flex gap-2.5 max-lg:flex-col">
                    <FacetedFilter
                      icon={PlusCircleIcon}
                      className="lg:flex-1"
                      value={searchParams.getAll('status')}
                      onChange={(statuses) => {
                        setSearchParams((searchParams) => {
                          searchParams.delete('status')
                          searchParams.delete('p')

                          if (statuses.length) {
                            statuses.forEach((s) =>
                              searchParams.has('status', s)
                                ? null
                                : searchParams.append('status', s)
                            )
                          }

                          return searchParams
                        })
                      }}
                      title="Status"
                      options={Object.entries(statuses).map(([key, value]) => ({
                        value: key,
                        ...value
                      }))}
                    />

                    <RangeCalendarFilter
                      className="lg:flex-1"
                      value={dateRange}
                      onChange={(dateRange) => {
                        setSearchParams((searchParams) => {
                          if (dateRange) {
                            searchParams.set(
                              'from',
                              `${rangeField}:${formatted.format(dateRange.from)}`
                            )
                            searchParams.set(
                              'to',
                              formatted.format(dateRange.to)
                            )
                          } else {
                            searchParams.delete('from')
                            searchParams.delete('to')
                          }

                          return searchParams
                        })
                      }}
                    >
                      <div className="p-2.5">
                        <Select
                          defaultValue={rangeField}
                          onValueChange={(value) => {
                            setSearchParams((searchParams) => {
                              if (searchParams.has('from')) {
                                searchParams.set(
                                  'from',
                                  `${value}:${dateRange?.from?.getTime()}`
                                )
                              }

                              return searchParams
                            })
                          }}
                        >
                          <SelectTrigger className="w-full">
                            <SelectValue />
                          </SelectTrigger>
                          <SelectContent>
                            <SelectGroup>
                              <SelectItem value="created_at">
                                Matriculado em
                              </SelectItem>
                              <SelectItem value="started_at">
                                Iniciado em
                              </SelectItem>
                              <SelectItem value="completed_at">
                                Aprovado em
                              </SelectItem>
                              <SelectItem value="failed_at">
                                Reprovado em
                              </SelectItem>
                              <SelectItem value="canceled_at">
                                Cancelado em
                              </SelectItem>
                            </SelectGroup>
                          </SelectContent>
                        </Select>
                      </div>
                    </RangeCalendarFilter>
                  </div>

                  <div className="lg:ml-auto flex gap-2.5">
                    <DataTableViewOptions className="flex-1" />

                    <Button className="flex-1" asChild>
                      <Link to="add">
                        <PlusIcon /> Adicionar
                      </Link>
                    </Button>
                  </div>
                </div>
              </div>
            </DataTable>
          )
        }}
      </Await>
    </Suspense>
  )
}

function useRangeParams(initRangeField: string) {
  const [searchParams] = useSearchParams()
  const [from, to] = [searchParams.get('from'), searchParams.get('to')]

  if (!from || !to) {
    return { rangeField: initRangeField, dateRange: undefined }
  }

  const [rangeField, from_] = from.split(':')

  return {
    rangeField,
    dateRange: {
      from: new Date(from_),
      to: new Date(to)
    }
  }
}