import { describe, it, expect, beforeEach, vi } from 'vitest'
import { useWorkoutStore } from '@/stores/workout-store'
import type { WorkoutExercise } from '@/stores/workout-store'

// Mock crypto.randomUUID
Object.defineProperty(global, 'crypto', {
  value: {
    randomUUID: vi.fn(() => 'test-uuid-' + Math.random()),
  },
  writable: true,
})

describe('workout-store', () => {
  const mockExercises: WorkoutExercise[] = [
    {
      id: 'we1',
      exerciseId: 'ex1',
      exercise: {
        id: 'ex1',
        name: 'Bench Press',
        mediaUrl: 'https://example.com/bench.mp4',
        mediaType: 'video/mp4',
      },
      order: 1,
      targetSets: 3,
      targetReps: 10,
      targetWeight: 100,
      restBetweenSetsSec: 60,
      restAfterExerciseSec: 120,
      note: 'Focus on form',
    },
    {
      id: 'we2',
      exerciseId: 'ex2',
      exercise: {
        id: 'ex2',
        name: 'Squats',
        mediaUrl: 'https://example.com/squats.mp4',
        mediaType: 'video/mp4',
      },
      order: 2,
      targetSets: 4,
      targetReps: 8,
      targetWeight: 150,
      restBetweenSetsSec: 90,
      restAfterExerciseSec: 120,
      note: null,
    },
  ]

  beforeEach(() => {
    // Reset store state before each test
    useWorkoutStore.setState({
      activeWorkout: null,
    })
  })

  describe('initWorkout', () => {
    it('should initialize workout in preview phase', () => {
      const { initWorkout } = useWorkoutStore.getState()

      initWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })

      const { activeWorkout } = useWorkoutStore.getState()

      expect(activeWorkout).not.toBeNull()
      expect(activeWorkout?.assignedWorkoutId).toBe('aw1')
      expect(activeWorkout?.templateId).toBe('t1')
      expect(activeWorkout?.exercises).toEqual(mockExercises)
      expect(activeWorkout?.currentExerciseIndex).toBe(0)
      expect(activeWorkout?.currentSetIndex).toBe(0)
      expect(activeWorkout?.isResting).toBe(false)
      expect(activeWorkout?.phase).toBe('preview')
      expect(activeWorkout?.startedAt).toBe('')
      expect(activeWorkout?.totalSetsTarget).toBe(7) // 3 + 4
      expect(activeWorkout?.totalSetsCompleted).toBe(0)
      expect(activeWorkout?.logs).toEqual([])
      expect(activeWorkout?.exerciseFeedbacks).toEqual([])
    })

    it('should calculate total sets correctly', () => {
      const { initWorkout } = useWorkoutStore.getState()

      initWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: [
          { ...mockExercises[0], targetSets: 5 },
          { ...mockExercises[1], targetSets: 3 },
        ],
      })

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.totalSetsTarget).toBe(8)
    })
  })

  describe('startWorkout', () => {
    it('should initialize workout in exercising phase with startedAt timestamp', () => {
      const { startWorkout } = useWorkoutStore.getState()
      const beforeTime = new Date().toISOString()

      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })

      const { activeWorkout } = useWorkoutStore.getState()
      const afterTime = new Date().toISOString()

      expect(activeWorkout).not.toBeNull()
      expect(activeWorkout?.phase).toBe('exercising')
      expect(activeWorkout?.startedAt).not.toBe('')
      expect(activeWorkout?.startedAt).toBeTruthy()
      // Verify timestamp is reasonable
      expect(activeWorkout!.startedAt >= beforeTime).toBe(true)
      expect(activeWorkout!.startedAt <= afterTime).toBe(true)
    })
  })

  describe('beginWorkout', () => {
    it('should transition from preview to exercising phase', () => {
      const { initWorkout, beginWorkout } = useWorkoutStore.getState()

      initWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })

      expect(useWorkoutStore.getState().activeWorkout?.phase).toBe('preview')
      expect(useWorkoutStore.getState().activeWorkout?.startedAt).toBe('')

      beginWorkout()

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.phase).toBe('exercising')
      expect(activeWorkout?.startedAt).not.toBe('')
    })

    it('should do nothing if no active workout', () => {
      const { beginWorkout } = useWorkoutStore.getState()

      beginWorkout()

      expect(useWorkoutStore.getState().activeWorkout).toBeNull()
    })
  })

  describe('logSet', () => {
    beforeEach(() => {
      const { startWorkout } = useWorkoutStore.getState()
      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })
    })

    it('should log a set with weight and reps', () => {
      const { logSet } = useWorkoutStore.getState()

      logSet({ weight: 100, reps: 10 })

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.logs).toHaveLength(1)
      expect(activeWorkout?.logs[0]).toMatchObject({
        exerciseId: 'ex1',
        setNumber: 1,
        weightUsed: 100,
        repsDone: 10,
      })
      expect(activeWorkout?.logs[0].id).toBeTruthy()
      expect(activeWorkout?.logs[0].loggedAt).toBeTruthy()
      expect(activeWorkout?.totalSetsCompleted).toBe(1)
    })

    it('should log a set with null weight (bodyweight)', () => {
      const { logSet } = useWorkoutStore.getState()

      logSet({ weight: null, reps: 15 })

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.logs).toHaveLength(1)
      expect(activeWorkout?.logs[0].weightUsed).toBeNull()
      expect(activeWorkout?.logs[0].repsDone).toBe(15)
    })

    it('should track set number correctly across multiple logs', () => {
      const { logSet, nextSet } = useWorkoutStore.getState()

      logSet({ weight: 100, reps: 10 })
      nextSet()
      logSet({ weight: 105, reps: 9 })
      nextSet()
      logSet({ weight: 105, reps: 8 })

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.logs).toHaveLength(3)
      expect(activeWorkout?.logs[0].setNumber).toBe(1)
      expect(activeWorkout?.logs[1].setNumber).toBe(2)
      expect(activeWorkout?.logs[2].setNumber).toBe(3)
    })

    it('should do nothing if no active workout', () => {
      useWorkoutStore.setState({ activeWorkout: null })
      const { logSet } = useWorkoutStore.getState()

      logSet({ weight: 100, reps: 10 })

      expect(useWorkoutStore.getState().activeWorkout).toBeNull()
    })
  })

  describe('rest timer', () => {
    beforeEach(() => {
      const { startWorkout } = useWorkoutStore.getState()
      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })
    })

    describe('startRest', () => {
      it('should start rest timer for set rest', () => {
        const { startRest } = useWorkoutStore.getState()

        startRest('set', 60)

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.isResting).toBe(true)
        expect(activeWorkout?.restType).toBe('set')
        expect(activeWorkout?.restTimeRemaining).toBe(60)
        expect(activeWorkout?.restTotalTime).toBe(60)
      })

      it('should start rest timer for exercise rest', () => {
        const { startRest } = useWorkoutStore.getState()

        startRest('exercise', 120)

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.isResting).toBe(true)
        expect(activeWorkout?.restType).toBe('exercise')
        expect(activeWorkout?.restTimeRemaining).toBe(120)
        expect(activeWorkout?.restTotalTime).toBe(120)
      })
    })

    describe('tickRest', () => {
      it('should decrement rest time', () => {
        const { startRest, tickRest } = useWorkoutStore.getState()

        startRest('set', 60)
        tickRest()

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.restTimeRemaining).toBe(59)
        expect(activeWorkout?.isResting).toBe(true)
      })

      it('should keep isResting true when time reaches zero', () => {
        const { startRest, tickRest } = useWorkoutStore.getState()

        startRest('set', 1)
        tickRest()

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.restTimeRemaining).toBe(0)
        expect(activeWorkout?.isResting).toBe(true)
      })

      it('should not go below zero', () => {
        const { startRest, tickRest } = useWorkoutStore.getState()

        startRest('set', 1)
        tickRest()
        tickRest() // second tick is a no-op since isResting is still true but time is 0

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.restTimeRemaining).toBe(0)
        expect(activeWorkout?.isResting).toBe(true)
      })

      it('should only set isResting to false via skipRest', () => {
        const { startRest, tickRest, skipRest } = useWorkoutStore.getState()

        startRest('set', 1)
        tickRest()

        // Timer is at 0 but isResting stays true
        expect(useWorkoutStore.getState().activeWorkout?.isResting).toBe(true)

        // Only skipRest sets isResting to false
        skipRest()

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.isResting).toBe(false)
        expect(activeWorkout?.restTimeRemaining).toBe(0)
      })

      it('should do nothing if not resting', () => {
        const { tickRest } = useWorkoutStore.getState()
        const before = useWorkoutStore.getState().activeWorkout

        tickRest()

        const after = useWorkoutStore.getState().activeWorkout
        expect(after).toEqual(before)
      })

      it('should do nothing if no active workout', () => {
        useWorkoutStore.setState({ activeWorkout: null })
        const { tickRest } = useWorkoutStore.getState()

        tickRest()

        expect(useWorkoutStore.getState().activeWorkout).toBeNull()
      })
    })

    describe('skipRest', () => {
      it('should skip rest timer', () => {
        const { startRest, skipRest } = useWorkoutStore.getState()

        startRest('set', 60)
        skipRest()

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.isResting).toBe(false)
        expect(activeWorkout?.restTimeRemaining).toBe(0)
      })

      it('should do nothing if no active workout', () => {
        useWorkoutStore.setState({ activeWorkout: null })
        const { skipRest } = useWorkoutStore.getState()

        skipRest()

        expect(useWorkoutStore.getState().activeWorkout).toBeNull()
      })
    })
  })

  describe('navigation', () => {
    beforeEach(() => {
      const { startWorkout } = useWorkoutStore.getState()
      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })
    })

    describe('nextSet', () => {
      it('should advance to next set within same exercise', () => {
        const { nextSet } = useWorkoutStore.getState()

        nextSet()

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.currentExerciseIndex).toBe(0)
        expect(activeWorkout?.currentSetIndex).toBe(1)
      })

      it('should advance to next exercise when completing last set', () => {
        const { nextSet } = useWorkoutStore.getState()

        // Complete all sets of first exercise (3 sets)
        nextSet() // Set 2
        nextSet() // Set 3
        nextSet() // Should move to exercise 2, set 1

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.currentExerciseIndex).toBe(1)
        expect(activeWorkout?.currentSetIndex).toBe(0)
      })

      it('should not advance past last set of last exercise', () => {
        const { nextSet } = useWorkoutStore.getState()

        // Move to last exercise
        useWorkoutStore.setState({
          activeWorkout: {
            ...useWorkoutStore.getState().activeWorkout!,
            currentExerciseIndex: 1,
            currentSetIndex: 3, // Last set
          },
        })

        nextSet()

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.currentExerciseIndex).toBe(1)
        expect(activeWorkout?.currentSetIndex).toBe(3)
      })

      it('should do nothing if no active workout', () => {
        useWorkoutStore.setState({ activeWorkout: null })
        const { nextSet } = useWorkoutStore.getState()

        nextSet()

        expect(useWorkoutStore.getState().activeWorkout).toBeNull()
      })
    })

    describe('nextExercise', () => {
      it('should advance to next exercise and reset set index', () => {
        const { nextExercise } = useWorkoutStore.getState()

        // Start at exercise 0, set 2
        useWorkoutStore.setState({
          activeWorkout: {
            ...useWorkoutStore.getState().activeWorkout!,
            currentSetIndex: 2,
          },
        })

        nextExercise()

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.currentExerciseIndex).toBe(1)
        expect(activeWorkout?.currentSetIndex).toBe(0)
      })

      it('should not advance past last exercise', () => {
        const { nextExercise } = useWorkoutStore.getState()

        // Move to last exercise
        useWorkoutStore.setState({
          activeWorkout: {
            ...useWorkoutStore.getState().activeWorkout!,
            currentExerciseIndex: 1,
          },
        })

        nextExercise()

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.currentExerciseIndex).toBe(1)
      })

      it('should do nothing if no active workout', () => {
        useWorkoutStore.setState({ activeWorkout: null })
        const { nextExercise } = useWorkoutStore.getState()

        nextExercise()

        expect(useWorkoutStore.getState().activeWorkout).toBeNull()
      })
    })

    describe('previousExercise', () => {
      it('should go back to previous exercise and reset state', () => {
        const { previousExercise } = useWorkoutStore.getState()

        // Start at exercise 1, set 2, resting
        useWorkoutStore.setState({
          activeWorkout: {
            ...useWorkoutStore.getState().activeWorkout!,
            currentExerciseIndex: 1,
            currentSetIndex: 2,
            isResting: true,
          },
        })

        previousExercise()

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.currentExerciseIndex).toBe(0)
        expect(activeWorkout?.currentSetIndex).toBe(0)
        expect(activeWorkout?.isResting).toBe(false)
      })

      it('should not go back from first exercise', () => {
        const { previousExercise } = useWorkoutStore.getState()

        previousExercise()

        const { activeWorkout } = useWorkoutStore.getState()
        expect(activeWorkout?.currentExerciseIndex).toBe(0)
      })

      it('should do nothing if no active workout', () => {
        useWorkoutStore.setState({ activeWorkout: null })
        const { previousExercise } = useWorkoutStore.getState()

        previousExercise()

        expect(useWorkoutStore.getState().activeWorkout).toBeNull()
      })
    })
  })

  describe('setPhase', () => {
    beforeEach(() => {
      const { startWorkout } = useWorkoutStore.getState()
      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })
    })

    it('should change phase to finishing', () => {
      const { setPhase } = useWorkoutStore.getState()

      setPhase('finishing')

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.phase).toBe('finishing')
    })

    it('should change phase to resting', () => {
      const { setPhase } = useWorkoutStore.getState()

      setPhase('resting')

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.phase).toBe('resting')
    })

    it('should do nothing if no active workout', () => {
      useWorkoutStore.setState({ activeWorkout: null })
      const { setPhase } = useWorkoutStore.getState()

      setPhase('finishing')

      expect(useWorkoutStore.getState().activeWorkout).toBeNull()
    })
  })

  describe('setExerciseFeedback', () => {
    beforeEach(() => {
      const { startWorkout } = useWorkoutStore.getState()
      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })
    })

    it('should add exercise feedback', () => {
      const { setExerciseFeedback } = useWorkoutStore.getState()

      setExerciseFeedback('ex1', 'Great form today!')

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.exerciseFeedbacks).toHaveLength(1)
      expect(activeWorkout?.exerciseFeedbacks[0]).toEqual({
        exerciseId: 'ex1',
        comment: 'Great form today!',
      })
    })

    it('should update existing feedback for same exercise', () => {
      const { setExerciseFeedback } = useWorkoutStore.getState()

      setExerciseFeedback('ex1', 'First comment')
      setExerciseFeedback('ex1', 'Updated comment')

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.exerciseFeedbacks).toHaveLength(1)
      expect(activeWorkout?.exerciseFeedbacks[0].comment).toBe('Updated comment')
    })

    it('should remove feedback when comment is empty', () => {
      const { setExerciseFeedback } = useWorkoutStore.getState()

      setExerciseFeedback('ex1', 'Test comment')
      setExerciseFeedback('ex1', '')

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.exerciseFeedbacks).toHaveLength(0)
    })

    it('should trim whitespace from comments', () => {
      const { setExerciseFeedback } = useWorkoutStore.getState()

      setExerciseFeedback('ex1', '  Trimmed comment  ')

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.exerciseFeedbacks[0].comment).toBe('Trimmed comment')
    })

    it('should handle multiple exercise feedbacks', () => {
      const { setExerciseFeedback } = useWorkoutStore.getState()

      setExerciseFeedback('ex1', 'Comment 1')
      setExerciseFeedback('ex2', 'Comment 2')

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.exerciseFeedbacks).toHaveLength(2)
    })

    it('should do nothing if no active workout', () => {
      useWorkoutStore.setState({ activeWorkout: null })
      const { setExerciseFeedback } = useWorkoutStore.getState()

      setExerciseFeedback('ex1', 'Test')

      expect(useWorkoutStore.getState().activeWorkout).toBeNull()
    })
  })

  describe('completeWorkout', () => {
    beforeEach(() => {
      const { startWorkout } = useWorkoutStore.getState()
      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })
    })

    it('should return active workout and clear state', () => {
      const { completeWorkout } = useWorkoutStore.getState()
      const before = useWorkoutStore.getState().activeWorkout

      const result = completeWorkout()

      expect(result).toEqual(before)
      expect(useWorkoutStore.getState().activeWorkout).toBeNull()
    })

    it('should return null if no active workout', () => {
      useWorkoutStore.setState({ activeWorkout: null })
      const { completeWorkout } = useWorkoutStore.getState()

      const result = completeWorkout()

      expect(result).toBeNull()
    })
  })

  describe('abandonWorkout', () => {
    beforeEach(() => {
      const { startWorkout } = useWorkoutStore.getState()
      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })
    })

    it('should clear active workout', () => {
      const { abandonWorkout } = useWorkoutStore.getState()

      abandonWorkout()

      expect(useWorkoutStore.getState().activeWorkout).toBeNull()
    })
  })

  describe('computed functions', () => {
    beforeEach(() => {
      const { startWorkout } = useWorkoutStore.getState()
      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })
    })

    describe('getCurrentExercise', () => {
      it('should return current exercise', () => {
        const { getCurrentExercise } = useWorkoutStore.getState()

        const exercise = getCurrentExercise()

        expect(exercise).toEqual(mockExercises[0])
      })

      it('should return correct exercise after navigation', () => {
        const { nextExercise, getCurrentExercise } = useWorkoutStore.getState()

        nextExercise()
        const exercise = getCurrentExercise()

        expect(exercise).toEqual(mockExercises[1])
      })

      it('should return null if no active workout', () => {
        useWorkoutStore.setState({ activeWorkout: null })
        const { getCurrentExercise } = useWorkoutStore.getState()

        const exercise = getCurrentExercise()

        expect(exercise).toBeNull()
      })

      it('should return null if exercise index out of bounds', () => {
        useWorkoutStore.setState({
          activeWorkout: {
            ...useWorkoutStore.getState().activeWorkout!,
            currentExerciseIndex: 999,
          },
        })
        const { getCurrentExercise } = useWorkoutStore.getState()

        const exercise = getCurrentExercise()

        expect(exercise).toBeNull()
      })
    })

    describe('getProgress', () => {
      it('should return progress with zero completed sets', () => {
        const { getProgress } = useWorkoutStore.getState()

        const progress = getProgress()

        expect(progress).toEqual({
          current: 0,
          total: 7,
          percentage: 0,
        })
      })

      it('should calculate progress after completing sets', () => {
        const { logSet, getProgress } = useWorkoutStore.getState()

        logSet({ weight: 100, reps: 10 })
        logSet({ weight: 100, reps: 10 })
        const progress = getProgress()

        expect(progress).toEqual({
          current: 2,
          total: 7,
          percentage: 29, // Math.round(2/7 * 100)
        })
      })

      it('should return 100% when all sets completed', () => {
        useWorkoutStore.setState({
          activeWorkout: {
            ...useWorkoutStore.getState().activeWorkout!,
            totalSetsCompleted: 7,
          },
        })
        const { getProgress } = useWorkoutStore.getState()

        const progress = getProgress()

        expect(progress).toEqual({
          current: 7,
          total: 7,
          percentage: 100,
        })
      })

      it('should return zero values if no active workout', () => {
        useWorkoutStore.setState({ activeWorkout: null })
        const { getProgress } = useWorkoutStore.getState()

        const progress = getProgress()

        expect(progress).toEqual({
          current: 0,
          total: 0,
          percentage: 0,
        })
      })
    })

    describe('isLastSet', () => {
      it('should return false for first set', () => {
        const { isLastSet } = useWorkoutStore.getState()

        expect(isLastSet()).toBe(false)
      })

      it('should return true for last set of exercise', () => {
        useWorkoutStore.setState({
          activeWorkout: {
            ...useWorkoutStore.getState().activeWorkout!,
            currentSetIndex: 2, // Exercise has 3 sets, so index 2 is last
          },
        })
        const { isLastSet } = useWorkoutStore.getState()

        expect(isLastSet()).toBe(true)
      })

      it('should return false if no active workout', () => {
        useWorkoutStore.setState({ activeWorkout: null })
        const { isLastSet } = useWorkoutStore.getState()

        expect(isLastSet()).toBe(false)
      })
    })

    describe('isLastExercise', () => {
      it('should return false for first exercise', () => {
        const { isLastExercise } = useWorkoutStore.getState()

        expect(isLastExercise()).toBe(false)
      })

      it('should return true for last exercise', () => {
        useWorkoutStore.setState({
          activeWorkout: {
            ...useWorkoutStore.getState().activeWorkout!,
            currentExerciseIndex: 1, // Only 2 exercises, so index 1 is last
          },
        })
        const { isLastExercise } = useWorkoutStore.getState()

        expect(isLastExercise()).toBe(true)
      })

      it('should return false if no active workout', () => {
        useWorkoutStore.setState({ activeWorkout: null })
        const { isLastExercise } = useWorkoutStore.getState()

        expect(isLastExercise()).toBe(false)
      })
    })
  })

  describe('persistence', () => {
    it('should persist activeWorkout state', () => {
      const { startWorkout } = useWorkoutStore.getState()

      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: mockExercises,
      })

      // Zustand persist middleware will handle actual persistence
      // We just verify the state is set correctly
      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout).not.toBeNull()
    })
  })

  describe('edge cases', () => {
    it('should handle empty exercises array', () => {
      const { initWorkout } = useWorkoutStore.getState()

      initWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: [],
      })

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.totalSetsTarget).toBe(0)
      expect(activeWorkout?.exercises).toEqual([])
    })

    it('should handle exercise with zero target sets', () => {
      const { initWorkout } = useWorkoutStore.getState()

      initWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: [{ ...mockExercises[0], targetSets: 0 }],
      })

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.totalSetsTarget).toBe(0)
    })

    it('should handle workout with single exercise', () => {
      const { startWorkout, nextExercise, isLastExercise } = useWorkoutStore.getState()

      startWorkout({
        assignedWorkoutId: 'aw1',
        templateId: 't1',
        exercises: [mockExercises[0]],
      })

      expect(isLastExercise()).toBe(true)
      nextExercise()

      const { activeWorkout } = useWorkoutStore.getState()
      expect(activeWorkout?.currentExerciseIndex).toBe(0)
    })
  })
})