"use client";

import {
  useCallback,
  useEffect,
  useMemo,
  useState,
} from "react";

import {
  type CategoryOption,
  type MinistryOption,
  type RgcDecisionRow,
  type RgcDecisionStatus,
} from "../rgc-decision-data";

import {
  createCdcRgcDecision,
  getCdcRgcDecisionLookups,
  getCdcRgcDecisions,
  type CreateCdcRgcDecisionInput,
  type IndicatorOption,
  type PlenaryOption,
  type IssueOption,
} from "../service/rgc-decision-service";

export function useRgcDecisions() {
  const [rows, setRows] = useState<RgcDecisionRow[]>([]);
  const [ministries, setMinistries] = useState<MinistryOption[]>([]);
  const [plenaries, setPlenaries] = useState<PlenaryOption[]>([]);
  const [categories, setCategories] = useState<CategoryOption[]>([]);
  const [indicators, setIndicators] = useState<IndicatorOption[]>([]);
  const [issues, setIssues] = useState<IssueOption[]>([]); // 🔥 State សម្រាប់ Issues

  const [loading, setLoading] = useState(true);
  const [lookupsLoading, setLookupsLoading] = useState(true);
  const [creating, setCreating] = useState(false);
  const [submitMode, setSubmitMode] = useState<
    "draft" | "send" | null
  >(null);
  const [error, setError] = useState<string | null>(null);

  const [selectedStatuses, setSelectedStatuses] =
    useState<RgcDecisionStatus[]>([]);
  const [selectedPrimaryAgencyIds, setSelectedPrimaryAgencyIds] =
    useState<number[]>([]);
  const [selectedCategoryIds, setSelectedCategoryIds] =
    useState<number[]>([]);
  const [meetingDate, setMeetingDate] = useState("");

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

      const items = await getCdcRgcDecisions();
      setRows(items);
    } catch (requestError) {
      setError(
        requestError instanceof Error
          ? requestError.message
          : "Unable to load RGC Decisions.",
      );
    } finally {
      setLoading(false);
    }
  }, []);

  const loadLookups = useCallback(async () => {
    try {
      setLookupsLoading(true);

      const result = await getCdcRgcDecisionLookups();

      setMinistries(result.ministries ?? []);
      setPlenaries(result.plenaries ?? []);
      setCategories(result.categories ?? []);
      setIndicators(result.indicators ?? []);
      setIssues(result.issues ?? []); // 🔥 កត់ត្រាទុកក្នុង State ឱ្យបានត្រឹមត្រូវ
    } catch (requestError) {
      setError(
        requestError instanceof Error
          ? requestError.message
          : "Unable to load form data.",
      );
    } finally {
      setLookupsLoading(false);
    }
  }, []);

  useEffect(() => {
    const timeoutId = window.setTimeout(() => {
      void Promise.all([loadRows(), loadLookups()]);
    }, 0);

    return () => {
      window.clearTimeout(timeoutId);
    };
  }, [loadLookups, loadRows]);

  const filteredRows = useMemo(() => {
    return rows.filter((row) => {
      const matchStatus =
        selectedStatuses.length === 0 ||
        selectedStatuses.includes(row.status);

      const matchAgency =
        selectedPrimaryAgencyIds.length === 0 ||
        selectedPrimaryAgencyIds.includes(row.stakeholderId);

      const matchCategory =
        selectedCategoryIds.length === 0 ||
        selectedCategoryIds.includes(row.categoryId);

      const matchMeetingDate =
        !meetingDate ||
        (row.meetingDate !== "-" &&
          row.meetingDate.slice(0, 7) === meetingDate);

      return (
        matchStatus &&
        matchAgency &&
        matchCategory &&
        matchMeetingDate
      );
    });
  }, [
    meetingDate,
    rows,
    selectedCategoryIds,
    selectedPrimaryAgencyIds,
    selectedStatuses,
  ]);

  const toggleStatus = useCallback((status: RgcDecisionStatus) => {
    setSelectedStatuses((current) =>
      current.includes(status)
        ? current.filter((item) => item !== status)
        : [...current, status],
    );
  }, []);

  const togglePrimaryAgency = useCallback((id: number) => {
    setSelectedPrimaryAgencyIds((current) =>
      current.includes(id)
        ? current.filter((item) => item !== id)
        : [...current, id],
    );
  }, []);

  const toggleCategory = useCallback((id: number) => {
    setSelectedCategoryIds((current) =>
      current.includes(id)
        ? current.filter((item) => item !== id)
        : [...current, id],
    );
  }, []);

  const resetFilters = useCallback(() => {
    setSelectedStatuses([]);
    setSelectedPrimaryAgencyIds([]);
    setSelectedCategoryIds([]);
    setMeetingDate("");
  }, []);

  const createDecision = useCallback(
    async (input: CreateCdcRgcDecisionInput) => {
      try {
        setCreating(true);
        setSubmitMode(
          input.saveAsDraft ? "draft" : "send",
        );
        setError(null);

        const created =
          await createCdcRgcDecision(input);

        setRows((current) => [
          created,
          ...current.filter((item) => item.id !== created.id),
        ]);

        return created;
      } catch (requestError) {
        const message =
          requestError instanceof Error
            ? requestError.message
            : input.saveAsDraft
              ? "Unable to save RGC Decision draft."
              : "Unable to create RGC Decision.";

        setError(message);
        throw new Error(message);
      } finally {
        setCreating(false);
        setSubmitMode(null);
      }
    },
    [],
  );

  return {
    rows,
    filteredRows,
    ministries,
    plenaries,
    categories,
    indicators,
    issues, // 🔥 Return issues ចេញទៅឱ្យ Page មេយកទៅប្រើប្រាស់
    loading,
    lookupsLoading,
    creating,
    submitMode,
    error,
    selectedStatuses,
    selectedPrimaryAgencyIds,
    selectedCategoryIds,
    meetingDate,
    toggleStatus,
    togglePrimaryAgency,
    toggleCategory,
    setMeetingDate,
    resetFilters,
    reload: loadRows,
    reloadLookups: loadLookups,
    createDecision,
  };
}

export default useRgcDecisions;