"use server";

import { revalidateTag } from "next/cache";
import { leaveService } from "@/services/leaveService";
import { LeaveRequest, LeaveBalance } from "@/types/leaveRequests";
import { getAuthHeaders } from "@/app/actions/config";
import { withServerAction } from "@/lib/server/server-action-wrapper";
import { CACHE_TAGS, DEFAULT_CACHE_PROFILE } from "./cache-tags";

export async function fetchUserLeavesAction(params: any): Promise<{ data: LeaveRequest[], total: number }> {
  return withServerAction(async () => {
    const headers = await getAuthHeaders();
    return await leaveService.getRequests(params, { headers });
  })
}

export async function fetchUserBalancesAction(): Promise<LeaveBalance[]> {
  return withServerAction(async () => {
    const headers = await getAuthHeaders();
    return await leaveService.getBalances({ headers });
  })
}

export async function createLeaveRequestAction(data: any) {
  return withServerAction(async () => {
    const headers = await getAuthHeaders();
    const result = await leaveService.createRequest(data, { headers });
    revalidateTag(CACHE_TAGS.leaves, DEFAULT_CACHE_PROFILE);
    revalidateTag(CACHE_TAGS.dashboard, DEFAULT_CACHE_PROFILE);
    return result;
  })
}

export async function fetchAllLeaveRequestsAction(params: any): Promise<{ data: LeaveRequest[], total: number }> {
  return withServerAction(async () => {
    const headers = await getAuthHeaders();
    return await leaveService.getAllRequests(params, { headers });
  })
}

export async function approveLeaveRequestAction(id: number) {
  return withServerAction(async () => {
    const headers = await getAuthHeaders();
    await leaveService.approveRequest(id, { headers });
    revalidateTag(CACHE_TAGS.leaves, DEFAULT_CACHE_PROFILE);
    revalidateTag(CACHE_TAGS.dashboard, DEFAULT_CACHE_PROFILE);
    return { success: true };
  })
}

export async function rejectLeaveRequestAction(id: number, reason?: string) {
  return withServerAction(async () => {
    const headers = await getAuthHeaders();
    await leaveService.rejectRequest(id, reason, { headers });
    revalidateTag(CACHE_TAGS.leaves, DEFAULT_CACHE_PROFILE);
    revalidateTag(CACHE_TAGS.dashboard, DEFAULT_CACHE_PROFILE);
    return { success: true };
  })
}

export async function cancelLeaveRequestAction(id: number) {
  return withServerAction(async () => {
    const headers = await getAuthHeaders();
    await leaveService.cancelRequest(id, { headers });
    revalidateTag(CACHE_TAGS.leaves, DEFAULT_CACHE_PROFILE);
    return { success: true };
  })
}

export async function assignInitialLeavesAction(userId: number) {
  return withServerAction(async () => {
    const headers = await getAuthHeaders();
    await leaveService.assignInitial(userId, { headers });
    revalidateTag(CACHE_TAGS.employees, DEFAULT_CACHE_PROFILE);
    revalidateTag(CACHE_TAGS.leaves, DEFAULT_CACHE_PROFILE);
    return { success: true };
  })
}

export async function fetchUserLeavesByHRAction(userId: number): Promise<LeaveRequest[]> {
  return withServerAction(async () => {
    const headers = await getAuthHeaders();
    return await leaveService.getUserRequestsByHR(userId, { headers });
  })
}

export async function updateLeaveBalanceAction(userId: number, leaveType: string, balance: number) {
  return withServerAction(async () => {
    const headers = await getAuthHeaders();
    await leaveService.updateBalance(userId, leaveType, balance, { headers });
    revalidateTag(CACHE_TAGS.employees, DEFAULT_CACHE_PROFILE);
    revalidateTag(CACHE_TAGS.leaves, DEFAULT_CACHE_PROFILE);
    return { success: true };
  })
}