import { createContext, useContext } from 'react';
import type { BaseEntity, BaseRemoteDataServices } from '@repo/core-api/data-services';
import type {
  ConfigSlice,
  DataServiceSlice,
  SelectionSlice,
  NavigationSlice,
  ModalSlice,
  TranslationSlice,
} from '../entities/entity';
import { StandardPaginationMeta } from '../../../../../core-api/src/data-services/base-data.transformer';

// ---------------------------------------------------------------------------
// Context Definitions
// ---------------------------------------------------------------------------

export const EnterpriseConfigContext = createContext<ConfigSlice<any> | null>(null);
export const EnterpriseDataServiceContext = createContext<DataServiceSlice<any, any> | null>(null);
export const EnterpriseSelectionContext = createContext<SelectionSlice<any, any, StandardPaginationMeta> | null>(null);
export const EnterpriseNavigationContext = createContext<NavigationSlice | null>(null);
export const EnterpriseModalContext = createContext<ModalSlice | null>(null);
export const EnterpriseTranslationContext = createContext<TranslationSlice | null>(null);

// ---------------------------------------------------------------------------
// Granular Hooks
// ---------------------------------------------------------------------------

export function useEnterpriseModuleConfigContext<E extends BaseEntity = BaseEntity>(): ConfigSlice<E> {
  const context = useContext(EnterpriseConfigContext);
  if (!context) {
    throw new Error('useEnterpriseModuleConfigContext must be used within an EnterpriseModuleProvider');
  }
  return context;
}

export function useEnterpriseModuleDataServiceContext<
  E extends BaseEntity = BaseEntity,
  S extends BaseRemoteDataServices<E> = BaseRemoteDataServices<E>,
>(): DataServiceSlice<E, S> {
  const context = useContext(EnterpriseDataServiceContext);
  if (!context) {
    throw new Error('useEnterpriseModuleDataServiceContext must be used within an EnterpriseModuleProvider');
  }
  return context;
}

export function useEnterpriseModuleSelectionContext<E extends BaseEntity = BaseEntity>(): SelectionSlice<
  E,
  any,
  StandardPaginationMeta
> {
  const context = useContext(EnterpriseSelectionContext);
  if (!context) {
    throw new Error('useEnterpriseModuleSelectionContext must be used within an EnterpriseModuleProvider');
  }
  return context;
}

export function useEnterpriseModuleNavigationContext(): NavigationSlice {
  const context = useContext(EnterpriseNavigationContext);
  if (!context) {
    throw new Error('useEnterpriseModuleNavigationContext must be used within an EnterpriseModuleProvider');
  }
  return context;
}

export function useEnterpriseModuleModalContext(): ModalSlice {
  const context = useContext(EnterpriseModalContext);
  if (!context) {
    throw new Error('useEnterpriseModuleModalContext must be used within an EnterpriseModuleProvider');
  }
  return context;
}

export function useEnterpriseModuleTranslationContext(): TranslationSlice {
  const context = useContext(EnterpriseTranslationContext);
  if (!context) {
    throw new Error('useEnterpriseModuleTranslationContext must be used within an EnterpriseModuleProvider');
  }
  return context;
}

// ---------------------------------------------------------------------------
// Composed Hook (Use Sparingly)
// ---------------------------------------------------------------------------

export function useEnterpriseModuleContext<E extends BaseEntity = BaseEntity>() {
  return {
    ...useEnterpriseModuleConfigContext<E>(),
    ...useEnterpriseModuleDataServiceContext<E>(),
    ...useEnterpriseModuleSelectionContext<E>(),
    ...useEnterpriseModuleNavigationContext(),
    ...useEnterpriseModuleModalContext(),
    ...useEnterpriseModuleTranslationContext(),
  };
}