import { create } from "zustand";
import { devtools } from "zustand/middleware";
import { Meeting, ActionItem } from "@/types";
import type { ListMeetingsPagination, ListMeetingsSummary, InvitedMeetingItem } from "@/types/api";

interface MeetingsState {
  meetings: Meeting[];
  invitedMeetings: InvitedMeetingItem[];
  activeMeetingId: string | null;
  listStatusFilter: string;
  pagination: ListMeetingsPagination | null;
  listSummary: ListMeetingsSummary | null;
  segmentCounts: Record<string, number>;
  loading: boolean;
  loadingMore: boolean;
  error: string | null;

  setMeetings: (meetings: Meeting[]) => void;
  setInvitedMeetings: (meetings: InvitedMeetingItem[]) => void;
  appendMeetings: (meetings: Meeting[]) => void;
  setListStatusFilter: (filter: string) => void;
  addMeeting: (meeting: Meeting) => void;
  updateMeeting: (id: string, patch: Partial<Meeting>) => void;
  deleteMeeting: (id: string) => void;
  setActiveMeeting: (id: string | null) => void;
  setPagination: (pagination: ListMeetingsPagination) => void;
  setListSummary: (summary: ListMeetingsSummary) => void;
  setSegmentCounts: (counts: Record<string, number>) => void;
  setLoading: (loading: boolean) => void;
  setLoadingMore: (loadingMore: boolean) => void;
  setError: (error: string | null) => void;
  toggleActionItem: (meetingId: string, actionItemId: string) => void;
}

export const useMeetingsStore = create<MeetingsState>()(
  devtools(
    (set) => ({
      meetings: [],
      invitedMeetings: [],
      activeMeetingId: null,
      listStatusFilter: "all",
      pagination: null,
      listSummary: null,
      segmentCounts: {},
      loading: false,
      loadingMore: false,
      error: null,

      setMeetings: (meetings) =>
        set({ meetings }, false, "meetings/setMeetings"),

      setInvitedMeetings: (invitedMeetings) =>
        set({ invitedMeetings }, false, "meetings/setInvitedMeetings"),

      appendMeetings: (newMeetings) =>
        set(
          (state) => {
            const existingIds = new Set(state.meetings.map((m) => m.id));
            const uniqueNewMeetings = newMeetings.filter((m) => !existingIds.has(m.id));
            return { meetings: [...state.meetings, ...uniqueNewMeetings] };
          },
          false,
          "meetings/appendMeetings"
        ),

      setListStatusFilter: (listStatusFilter) =>
        set({ listStatusFilter }, false, "meetings/setListStatusFilter"),

      addMeeting: (meeting) =>
        set(
          (state) => ({ meetings: [meeting, ...state.meetings] }),
          false,
          "meetings/addMeeting"
        ),

      updateMeeting: (id, patch) =>
        set(
          (state) => ({
            meetings: state.meetings.map((m) => (m.id === id ? { ...m, ...patch } : m)),
          }),
          false,
          "meetings/updateMeeting"
        ),

      deleteMeeting: (id) =>
        set(
          (state) => ({ meetings: state.meetings.filter((m) => m.id !== id) }),
          false,
          "meetings/deleteMeeting"
        ),

      setActiveMeeting: (id) =>
        set({ activeMeetingId: id }, false, "meetings/setActiveMeeting"),

      setPagination: (pagination) =>
        set({ pagination }, false, "meetings/setPagination"),

      setListSummary: (listSummary) =>
        set({ listSummary }, false, "meetings/setListSummary"),

      setSegmentCounts: (segmentCounts) =>
        set({ segmentCounts }, false, "meetings/setSegmentCounts"),

      setLoading: (loading) =>
        set({ loading }, false, "meetings/setLoading"),

      setLoadingMore: (loadingMore) =>
        set({ loadingMore }, false, "meetings/setLoadingMore"),

      setError: (error) =>
        set({ error }, false, "meetings/setError"),

      toggleActionItem: (meetingId, actionItemId) =>
        set(
          (state) => ({
            meetings: state.meetings.map((m) => {
              if (m.id !== meetingId || !m.summary) return m;
              return {
                ...m,
                summary: {
                  ...m.summary,
                  actionItems: m.summary.actionItems.map((a: ActionItem) =>
                    a.id === actionItemId ? { ...a, completed: !a.completed } : a
                  ),
                },
              };
            }),
          }),
          false,
          "meetings/toggleActionItem"
        ),
    }),
    { name: "MeetingsStore" }
  )
);