'use client';

import { useState, useCallback, useEffect } from 'react';
import {
  WorkoutSession,
  UserMetrics,
  saveWorkoutSession,
  getWorkoutSessions,
  updateWorkoutSession,
  deleteWorkoutSession,
  getWorkoutsByType,
  getWorkoutsByDateRange,
  saveUserMetrics,
  getUserMetrics,
  updateUserMetrics,
  calculateMetricsFromSessions
} from '@/lib/storage/workoutStorage';

export const useWorkoutData = () => {
  const [sessions, setSessions] = useState<WorkoutSession[]>([]);
  const [metrics, setMetrics] = useState<UserMetrics | null>(null);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  // Load initial data
  useEffect(() => {
    try {
      setIsLoading(true);
      const loadedSessions = getWorkoutSessions();
      const loadedMetrics = getUserMetrics();
      setSessions(loadedSessions);
      setMetrics(loadedMetrics);
      setError(null);
    } catch (err) {
      setError('Failed to load workout data');
      console.error(err);
    } finally {
      setIsLoading(false);
    }
  }, []);

  const addSession = useCallback((session: Omit<WorkoutSession, 'id'>) => {
    try {
      const newSession: WorkoutSession = {
        ...session,
        id: Date.now().toString()
      };
      const success = saveWorkoutSession(newSession);
      if (success) {
        setSessions(prev => [...prev, newSession]);
        // Recalculate metrics
        const updatedMetrics = calculateMetricsFromSessions();
        setMetrics(updatedMetrics);
        saveUserMetrics(updatedMetrics);
      }
      return success;
    } catch (err) {
      setError('Failed to add session');
      console.error(err);
      return false;
    }
  }, []);

  const updateSession = useCallback((id: string, updates: Partial<WorkoutSession>) => {
    try {
      const success = updateWorkoutSession(id, updates);
      if (success) {
        setSessions(prev =>
          prev.map(s => s.id === id ? { ...s, ...updates } : s)
        );
        // Recalculate metrics
        const updatedMetrics = calculateMetricsFromSessions();
        setMetrics(updatedMetrics);
        saveUserMetrics(updatedMetrics);
      }
      return success;
    } catch (err) {
      setError('Failed to update session');
      console.error(err);
      return false;
    }
  }, []);

  const removeSession = useCallback((id: string) => {
    try {
      const success = deleteWorkoutSession(id);
      if (success) {
        setSessions(prev => prev.filter(s => s.id !== id));
        // Recalculate metrics
        const updatedMetrics = calculateMetricsFromSessions();
        setMetrics(updatedMetrics);
        saveUserMetrics(updatedMetrics);
      }
      return success;
    } catch (err) {
      setError('Failed to delete session');
      console.error(err);
      return false;
    }
  }, []);

  const getSessionsByType = useCallback((type: 'cardio' | 'training' | 'nutrition') => {
    try {
      return getWorkoutsByType(type);
    } catch (err) {
      setError('Failed to filter sessions');
      console.error(err);
      return [];
    }
  }, []);

  const getSessionsByDate = useCallback((startDate: string, endDate: string) => {
    try {
      return getWorkoutsByDateRange(startDate, endDate);
    } catch (err) {
      setError('Failed to filter sessions by date');
      console.error(err);
      return [];
    }
  }, []);

  const updateMetrics = useCallback((updates: Partial<UserMetrics>) => {
    try {
      const success = updateUserMetrics(updates);
      if (success) {
        setMetrics(prev => prev ? { ...prev, ...updates } : null);
      }
      return success;
    } catch (err) {
      setError('Failed to update metrics');
      console.error(err);
      return false;
    }
  }, []);

  const refreshMetrics = useCallback(() => {
    try {
      const recalculated = calculateMetricsFromSessions();
      setMetrics(recalculated);
      saveUserMetrics(recalculated);
      return recalculated;
    } catch (err) {
      setError('Failed to refresh metrics');
      console.error(err);
      return null;
    }
  }, []);

  return {
    sessions,
    metrics,
    isLoading,
    error,
    addSession,
    updateSession,
    removeSession,
    getSessionsByType,
    getSessionsByDate,
    updateMetrics,
    refreshMetrics
  };
};