"use client";

import { useCallback, useState } from "react";

import {
  cdcGpsfMeetingRequestService,
  type ApiGovernmentAgency,
  type ApiMeetingRequest,
  type ApiWorkingGroup,
} from "@/features/cdc-gpsf/meeting-requests/service/cdc-gpsf-meeting-request-service";

function isApiMeetingRequest(value: unknown): value is ApiMeetingRequest {
  if (!value || typeof value !== "object") return false;

  const id = (value as { id?: unknown }).id;

  return typeof id === "number" && Number.isFinite(id);
}

function keepValidMeetingRequests(
  items: ApiMeetingRequest[],
): ApiMeetingRequest[] {
  return items.filter((item) => isApiMeetingRequest(item));
}

export function useCdcGpsfMeetingRequests() {
  const [data, setData] = useState<ApiMeetingRequest[]>([]);
  const [selected, setSelected] = useState<ApiMeetingRequest | null>(null);

  const [agencies, setAgencies] = useState<ApiGovernmentAgency[]>([]);
  const [workingGroups, setWorkingGroups] = useState<ApiWorkingGroup[]>([]);

  const [loading, setLoading] = useState<boolean>(false);
  const [detailLoading, setDetailLoading] = useState<boolean>(false);
  const [loadingAgencies, setLoadingAgencies] = useState<boolean>(false);
  const [loadingWorkingGroups, setLoadingWorkingGroups] =
    useState<boolean>(false);

  const [error, setError] = useState<string | null>(null);

  const fetchGovernmentAgencies = useCallback(async () => {
    try {
      setLoadingAgencies(true);

      const result = await cdcGpsfMeetingRequestService.getGovernmentAgencies();
      const safeResult = Array.isArray(result) ? result : [];

      setAgencies(safeResult);

      return safeResult;
    } catch {
      setAgencies([]);

      return [];
    } finally {
      setLoadingAgencies(false);
    }
  }, []);

  const fetchWorkingGroups = useCallback(async () => {
    try {
      setLoadingWorkingGroups(true);

      const result = await cdcGpsfMeetingRequestService.getWorkingGroups();
      const safeResult = Array.isArray(result) ? result : [];

      setWorkingGroups(safeResult);

      return safeResult;
    } catch {
      setWorkingGroups([]);

      return [];
    } finally {
      setLoadingWorkingGroups(false);
    }
  }, []);

  const fetchMeetingRequests = useCallback(async () => {
    try {
      setLoading(true);
      setError(null);

      const result = await cdcGpsfMeetingRequestService.getAll();
      const safeResult = Array.isArray(result)
        ? keepValidMeetingRequests(result)
        : [];

      setData(safeResult);

      return safeResult;
    } catch (err: unknown) {
      const message =
        err instanceof Error
          ? err.message
          : "Failed to fetch meeting requests";

      setError(message);
      setData([]);

      return [];
    } finally {
      setLoading(false);
    }
  }, []);

  const fetchMeetingRequestById = useCallback(async (id: number) => {
    try {
      setDetailLoading(true);
      setError(null);

      const result = await cdcGpsfMeetingRequestService.getById(id);

      setSelected(result);

      return result;
    } catch (err: unknown) {
      const message =
        err instanceof Error
          ? err.message
          : "Failed to fetch meeting request";

      setError(message);
      setSelected(null);

      return null;
    } finally {
      setDetailLoading(false);
    }
  }, []);

  return {
    data,
    selected,
    agencies,
    workingGroups,
    loading,
    detailLoading,
    loadingAgencies,
    loadingWorkingGroups,
    error,
    fetchGovernmentAgencies,
    fetchWorkingGroups,
    fetchMeetingRequests,
    fetchMeetingRequestById,
  };
}