'use client';

import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { api } from '@/lib/api';
import type {
  InvitationInput,
  MembershipUpdateInput,
  PayRateInput,
  PositionInput,
  PositionUpdateInput,
} from '@alqove/api-client';

export const TEAM_KEYS = {
  members: (storeId: string) => ['team', 'members', storeId] as const,
  payRates: (storeId: string, membershipId: string) =>
    ['team', 'pay-rates', storeId, membershipId] as const,
  positions: (storeId: string) => ['team', 'positions', storeId] as const,
  invitations: (storeId: string) => ['team', 'invitations', storeId] as const,
};

function invalidateMembers(qc: ReturnType<typeof useQueryClient>, storeId: string) {
  qc.invalidateQueries({ queryKey: ['team', 'members', storeId] });
}

export function useStoreMembers(storeId: string | null | undefined) {
  return useQuery({
    queryKey: storeId ? TEAM_KEYS.members(storeId) : ['team', 'members', 'none'],
    queryFn: () => api.team.members.list(storeId!),
    enabled: Boolean(storeId),
    staleTime: 30_000,
  });
}

export function useUpdateMember() {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: ({
      storeId,
      membershipId,
      input,
    }: {
      storeId: string;
      membershipId: string;
      input: MembershipUpdateInput;
    }) => api.team.members.update(storeId, membershipId, input),
    onSuccess: (_data, { storeId }) => invalidateMembers(qc, storeId),
  });
}

export function useTerminateMember() {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: ({ storeId, membershipId }: { storeId: string; membershipId: string }) =>
      api.team.members.terminate(storeId, membershipId),
    onSuccess: (_data, { storeId }) => invalidateMembers(qc, storeId),
  });
}

export function useMemberPayRates(
  storeId: string | null | undefined,
  membershipId: string | null | undefined,
) {
  return useQuery({
    queryKey:
      storeId && membershipId
        ? TEAM_KEYS.payRates(storeId, membershipId)
        : ['team', 'pay-rates', 'none'],
    queryFn: () => api.team.payRates.list(storeId!, membershipId!),
    enabled: Boolean(storeId && membershipId),
    staleTime: 30_000,
  });
}

export function useCreatePayRate() {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: ({
      storeId,
      membershipId,
      input,
    }: {
      storeId: string;
      membershipId: string;
      input: PayRateInput;
    }) => api.team.payRates.create(storeId, membershipId, input),
    onSuccess: (_data, { storeId, membershipId }) => {
      qc.invalidateQueries({ queryKey: TEAM_KEYS.payRates(storeId, membershipId) });
      // The roster shows current_pay_rate_cents.
      invalidateMembers(qc, storeId);
    },
  });
}

export function useStorePositions(storeId: string | null | undefined) {
  return useQuery({
    queryKey: storeId ? TEAM_KEYS.positions(storeId) : ['team', 'positions', 'none'],
    queryFn: () => api.team.positions.list(storeId!),
    enabled: Boolean(storeId),
    staleTime: 60_000,
  });
}

export function useCreatePosition() {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: ({ storeId, input }: { storeId: string; input: PositionInput }) =>
      api.team.positions.create(storeId, input),
    onSuccess: (_data, { storeId }) =>
      qc.invalidateQueries({ queryKey: TEAM_KEYS.positions(storeId) }),
  });
}

export function useUpdatePosition() {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: ({
      storeId,
      positionId,
      input,
    }: {
      storeId: string;
      positionId: string;
      input: PositionUpdateInput;
    }) => api.team.positions.update(storeId, positionId, input),
    onSuccess: (_data, { storeId }) => {
      qc.invalidateQueries({ queryKey: TEAM_KEYS.positions(storeId) });
      invalidateMembers(qc, storeId);
    },
  });
}

export function useStoreInvitations(storeId: string | null | undefined) {
  return useQuery({
    queryKey: storeId ? TEAM_KEYS.invitations(storeId) : ['team', 'invitations', 'none'],
    queryFn: () => api.team.invitations.list(storeId!),
    enabled: Boolean(storeId),
    staleTime: 30_000,
  });
}

export function useCreateInvitation() {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: ({ storeId, input }: { storeId: string; input: InvitationInput }) =>
      api.team.invitations.create(storeId, input),
    onSuccess: (_data, { storeId }) =>
      qc.invalidateQueries({ queryKey: TEAM_KEYS.invitations(storeId) }),
  });
}

export function useRevokeInvitation() {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: ({ storeId, invitationId }: { storeId: string; invitationId: string }) =>
      api.team.invitations.revoke(storeId, invitationId),
    onSuccess: (_data, { storeId }) =>
      qc.invalidateQueries({ queryKey: TEAM_KEYS.invitations(storeId) }),
  });
}