LinkDesk/frontend/src/stores/episodes.ts

import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import { episodeService, type Episode, type EpisodeCreate, type EpisodeUpdate } from '@/services/episode'
import { useAsyncAction } from '@/composables/useAsyncAction'

export const useEpisodesStore = defineStore('episodes', () => {
  // State
  const episodes = ref<Episode[]>([])
  const currentEpisode = ref<Episode | null>(null)
  const isLoading = ref(false)
  const error = ref<string | null>(null)
  const { run } = useAsyncAction({ isLoading, error })

  // Getters
  const getEpisodeById = computed(() => {
    return (id: number) => episodes.value.find(episode => episode.id === id)
  })

  const getEpisodesByProject = computed(() => {
    return (projectId: number) => episodes.value.filter(episode => episode.project_id === projectId)
  })

  const episodesByStatus = computed(() => {
    return (status: string) => episodes.value.filter(episode => episode.status === status)
  })

  // Actions
  const fetchEpisodes = async (projectId?: number) => {
    return run(async () => {
      episodes.value = projectId
        ? await episodeService.getProjectEpisodes(projectId)
        : await episodeService.getEpisodes()
    }, { errorMessage: 'Failed to fetch episodes' })
  }

  const fetchEpisode = async (episodeId: number) => {
    return run(async () => {
      const episode = await episodeService.getEpisode(episodeId)

      // Update the episode in the list if it exists
      const index = episodes.value.findIndex(e => e.id === episodeId)
      if (index !== -1) {
        episodes.value[index] = episode
      } else {
        episodes.value.push(episode)
      }

      currentEpisode.value = episode
      return episode
    }, { errorMessage: 'Failed to fetch episode' })
  }

  const createEpisode = async (projectId: number, episodeData: EpisodeCreate) => {
    return run(async () => {
      const newEpisode = await episodeService.createEpisode(projectId, episodeData)
      episodes.value.push(newEpisode)
      return newEpisode
    }, { errorMessage: 'Failed to create episode' })
  }

  const updateEpisode = async (episodeId: number, episodeData: EpisodeUpdate) => {
    return run(async () => {
      const updatedEpisode = await episodeService.updateEpisode(episodeId, episodeData)

      // Update the episode in the list
      const index = episodes.value.findIndex(e => e.id === episodeId)
      if (index !== -1) {
        episodes.value[index] = updatedEpisode
      }

      // Update current episode if it's the same
      if (currentEpisode.value?.id === episodeId) {
        currentEpisode.value = updatedEpisode
      }

      return updatedEpisode
    }, { errorMessage: 'Failed to update episode' })
  }

  const deleteEpisode = async (episodeId: number) => {
    return run(async () => {
      await episodeService.deleteEpisode(episodeId)

      // Remove the episode from the list
      episodes.value = episodes.value.filter(e => e.id !== episodeId)

      // Clear current episode if it's the deleted one
      if (currentEpisode.value?.id === episodeId) {
        currentEpisode.value = null
      }
    }, { errorMessage: 'Failed to delete episode' })
  }

  const setCurrentEpisode = (episode: Episode | null) => {
    currentEpisode.value = episode
  }

  const clearError = () => {
    error.value = null
  }

  const clearEpisodes = () => {
    episodes.value = []
    currentEpisode.value = null
    error.value = null
  }

  return {
    // State
    episodes,
    currentEpisode,
    isLoading,
    error,
    
    // Getters
    getEpisodeById,
    getEpisodesByProject,
    episodesByStatus,
    
    // Actions
    fetchEpisodes,
    fetchEpisode,
    createEpisode,
    updateEpisode,
    deleteEpisode,
    setCurrentEpisode,
    clearError,
    clearEpisodes
  }
})

export type { Episode, EpisodeCreate, EpisodeUpdate }