import { useState, useEffect, useCallback, useMemo } from "react";
import {
  getMisActionList,
  type MisActionRow,
  type MisActionFilters,
} from "@/lib/services/misActionService";
import type { MonthYearValue } from "@/components/ui/month-year-select";
import { useDebounce } from "../useDebounce";
import { useAppDispatch, useAppSelector } from "@/lib/hooks";
import { saveFilter } from "@/lib/features/filter/filterSlice";

interface UseMisActionState {
  data: MisActionRow[];
  loading: boolean;
  error: string | null;
  search: string;
  period: MonthYearValue;
  year: string;
  statusFilter: string;
}

interface UseMisActionActions {
  setSearch: (v: string) => void;
  setPeriod: (v: MonthYearValue) => void;
  setYear: (v: string) => void;
  setStatusFilter: (v: string) => void;
  refreshData: () => Promise<void>;
}

const getInitialPeriod = (): MonthYearValue => {
  const now = new Date();
  return { month: now.getMonth(), year: now.getFullYear() };
};

const getInitialYear = (): string => String(new Date().getFullYear());

export function useMisAction() {
  const filterData = useAppSelector((s) => s?.filter);

  const INITIAL_STATE: UseMisActionState = {
    data: [],
    loading: false,
    error: null,
    search: filterData?.misAction?.search || "",
    period: filterData?.misAction?.period || getInitialPeriod(),
    year: filterData?.misAction?.year || getInitialYear(),
    statusFilter: "all",
  };

  const [state, setState] = useState<UseMisActionState>(INITIAL_STATE);

  const debouncedSearchTerm = useDebounce(state.search, 500);

  const dispatch = useAppDispatch();

  const fetchData = useCallback(async () => {
    setState((prev) => ({ ...prev, loading: true, error: null }));
    const filters: MisActionFilters = {
      search: debouncedSearchTerm || undefined,
      year: state.year,
      month:
        state.period.month !== null ? String(state.period.month) : undefined,
      status: state.statusFilter !== "all" ? state.statusFilter : undefined,
    };

    const result: any = await getMisActionList(filters);

    if (result.success && result.data) {
      setState((prev) => ({
        ...prev,
        data: result.data?.data ?? [],
        loading: false,
        error: null,
      }));
    } else {
      setState((prev) => ({
        ...prev,
        data: [],
        loading: false,
        error: result.message ?? "Failed to load data",
      }));
    }
  }, [
    debouncedSearchTerm,
    state.period.year,
    state.period.month,
    state.year,
    state.statusFilter,
  ]);

  useEffect(() => {
    fetchData();
  }, [fetchData]);

  const setSearch = useCallback((search: string) => {
    setState((prev) => ({ ...prev, search }));
  }, []);

  const setPeriod = useCallback((period: MonthYearValue) => {
    setState((prev) => ({ ...prev, period }));
  }, []);

  const setYear = useCallback((year: string) => {
    setState((prev) => ({ ...prev, year }));
  }, []);

  const setStatusFilter = useCallback((statusFilter: string) => {
    setState((prev) => ({ ...prev, statusFilter }));
  }, []);

  const refreshData = useCallback(async () => {
    await fetchData();
  }, [fetchData]);

  const filteredData = useMemo(() => {
    let rows = state.data;

    // if (state.search.trim()) {
    //   const q = state.search.toLowerCase();
    //   rows = rows.filter((row) => row.employeeName.toLowerCase().includes(q));
    // }

    if (state.statusFilter !== "all") {
      rows = rows.filter((row) => row.status === state.statusFilter);
    }

    return rows;
  }, [state.data, state.search, state.statusFilter]);

  useEffect(() => {
    dispatch(
      saveFilter({
        moduleName: "misAction",
        data: { year: state.year, period: state.period, search: state.search },
      }),
    );
  }, [state]);

  return {
    ...state,
    data: filteredData,
    setSearch,
    setPeriod,
    setYear,
    setStatusFilter,
    refreshData,
  } as UseMisActionState & UseMisActionActions;
}