import { ToolSchedule } from '@superglue/shared'
import { createContext, ReactNode, useCallback, useContext, useEffect, useState } from 'react'
import { useConfig } from './config-context'
import { loadFromCache, saveToCache } from '@/src/lib/cache-utils'
import { createSuperglueClient } from '../lib/client-utils'
interface SchedulesContextType {
schedules: ToolSchedule[]
isInitiallyLoading: boolean
isRefreshing: boolean
refreshSchedules: () => Promise<void>
getSchedulesForTool: (toolId: string) => ToolSchedule[]
}
export type CachedSchedules = {
schedules: ToolSchedule[]
timestamp: number
}
const CACHE_PREFIX = 'superglue-schedules';
const SchedulesContext = createContext<SchedulesContextType | null>(null);
export function SchedulesProvider({ children }: { children: ReactNode }) {
const config = useConfig()
const [schedules, setSchedules] = useState<ToolSchedule[]>([])
const [isInitiallyLoading, setIsInitiallyLoading] = useState(false)
const [isRefreshing, setIsRefreshing] = useState(false)
const refreshSchedules = useCallback(async () => {
setIsRefreshing(true)
try {
const client = createSuperglueClient(config.superglueEndpoint);
const result = await client.listWorkflowSchedules();
setSchedules(result);
const toCache: CachedSchedules = {
schedules: result,
timestamp: Date.now()
}
saveToCache(CACHE_PREFIX, toCache);
} catch (error) {
console.error('Error loading schedules:', error)
} finally {
setIsInitiallyLoading(false)
setIsRefreshing(false)
}
}, [config.superglueEndpoint])
const getSchedulesForTool = useCallback((toolId: string): ToolSchedule[] => {
return schedules.filter(s => s.workflowId === toolId);
}, [schedules])
useEffect(() => {
const cachedSchedules = loadFromCache<CachedSchedules>(CACHE_PREFIX);
if (cachedSchedules) {
setSchedules(cachedSchedules.schedules);
setIsInitiallyLoading(false);
} else {
setIsInitiallyLoading(true);
}
refreshSchedules()
}, [config.superglueEndpoint, refreshSchedules])
const context: SchedulesContextType = {
schedules,
isInitiallyLoading,
isRefreshing,
refreshSchedules,
getSchedulesForTool
}
return <SchedulesContext.Provider value={context}>{children}</SchedulesContext.Provider>;
}
export function useSchedules(): SchedulesContextType {
const context = useContext(SchedulesContext);
if (!context) {
throw new Error('useSchedules must be used within a SchedulesProvider.');
}
return context;
}