import { createContext, ReactNode, useCallback, useMemo } from 'react';
import {
  useCreateOrganization,
  useDeleteOrganization,
  useOrganizations as useOrganizationsAPI,
} from '@/hooks/api';
import type {
  BackendOrganization,
  CreateOrganizationRequest,
} from '@/schemas/backend/organization';

interface OrganizationContextType {
  organizations: BackendOrganization[];
  isLoading: boolean;
  error: Error | null;
  addOrganization: (newOrgData: CreateOrganizationRequest) => Promise<void>;
  updateOrganization: () => Promise<void>;
  deleteOrganization: (id: string) => Promise<void>;
  getOrganizationById: (id: string | undefined) => BackendOrganization | undefined;
  refetch: () => void;
}

export const OrganizationContext = createContext<OrganizationContextType | undefined>(undefined);

export const OrganizationProvider = ({ children }: { children?: ReactNode }) => {
  const { data: organizations, isLoading, error, refetch } = useOrganizationsAPI();
  const createOrgMutation = useCreateOrganization();
  const deleteOrgMutation = useDeleteOrganization();

  const addOrganization = useCallback(
    async (newOrgData: CreateOrganizationRequest) => {
      await createOrgMutation.mutateAsync(newOrgData);
      refetch();
    },
    [createOrgMutation, refetch]
  );

  const updateOrganization = useCallback(async () => {
    throw new Error(
      'Organization updates are not yet supported by the backend API. This feature will be implemented when the backend adds support for organization updates.'
    );
  }, []);

  const deleteOrganization = useCallback(
    async (id: string) => {
      await deleteOrgMutation.mutateAsync(id);
      refetch();
    },
    [deleteOrgMutation, refetch]
  );

  const getOrganizationById = useCallback(
    (id: string | undefined): BackendOrganization | undefined => {
      if (!id || !organizations || !Array.isArray(organizations)) return undefined;
      return organizations.find((org) => org.ID === id);
    },
    [organizations]
  );

  const value = useMemo(() => {
    // Ensure organizations is always an array - don't block on undefined
    const orgs = Array.isArray(organizations) ? organizations : [];

    // Only log in development and avoid blocking with console operations
    if (process.env.NODE_ENV === 'development') {
      // Use setTimeout to defer logging and not block render
      setTimeout(() => {
        console.log(`[OrganizationContext] Loaded ${orgs.length} organizations`, {
          isLoading,
          hasError: !!error,
          error: error?.message,
          sample: orgs.slice(0, 3).map((org) => ({ id: org?.ID, name: org?.Name })),
        });
        const orgsWithoutIds = orgs.filter((org) => !org?.ID || org.ID.trim() === '');
        if (orgsWithoutIds.length > 0) {
          console.warn(`Found ${orgsWithoutIds.length} organizations without valid IDs`);
        }
      }, 0);
    }

    return {
      organizations: orgs,
      isLoading,
      error: error instanceof Error ? error : error ? new Error(String(error)) : null,
      addOrganization,
      updateOrganization,
      deleteOrganization,
      getOrganizationById,
      refetch,
    };
  }, [
    organizations,
    isLoading,
    error,
    addOrganization,
    updateOrganization,
    deleteOrganization,
    getOrganizationById,
    refetch,
  ]);

  return <OrganizationContext.Provider value={value}>{children}</OrganizationContext.Provider>;
};