/*
 * @copyright Copyright (c) 2021 Jonas Heinrich <onny@project-insanity.org>
 *
 * @author Jonas Heinrich <onny@project-insanity.org>
 *
 * @license GNU AGPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 */

import { Player } from './../services/Player'
import { FyydApi } from './../services/FyydApi'

const player = new Player()
const fyydClient = new FyydApi()

export default {
	state: {
		isPlaying: false,
		isBuffering: false,
		isMute: false,
		isPaused: false,
		volume: 0.5,
		oldVolume: null,
		title: '',
		image: '',
		episodeId: null,
		duration: null,
		seek: 0,
		lastplaytimeupdate: null,
		podcastName: '',
	},
	getters: {
		getTitle: state => {
			return state.title
		},
		getPodcastName: state => {
			return state.podcastName
		},
		getImage: state => {
			return state.image
		},
		getSeek: state => {
			if (state.seek) {
				return state.seek
			} else {
				return 0
			}
		},
		getDuration: state => {
			return state.duration
		},
		getVolume: state => {
			return state.volume
		},
		isPlaying: state => {
			return state.isPlaying
		},
		isBuffering: state => {
			return state.isBuffering
		},
		isPaused: state => (id) => {
			return (state.episodeId === id && state.isPaused)
		},
		episodeLoaded: state => (id) => {
			return (state.episodeId === id)
		},
		episodePlaying: state => (id) => {
			return (state.episodeId === id && state.isPlaying)
		},
	},
	mutations: {
		setVolume(state, volume) {
			state.volume = volume
			localStorage.setItem('podcast.volume', state.volume)
			player.volume(state.volume)
		},
		toggleMute(state) {
			if (state.isMute) {
				state.volume = state.oldVolume
				state.isMute = false
			} else {
				if (state.volume === 0) {
					state.volume = 1
				} else {
					state.oldVolume = state.volume
					state.volume = 0
					state.isMute = true
				}
			}
			localStorage.setItem('podcast.volume', state.volume)
			player.volume(state.volume)
		},
		setTitle(state, title) {
			state.title = title
		},
		setDuration(state, duration) {
			duration = Math.round(duration)
			state.duration = duration
		},
		setSeek(state, seek) {
			seek = Math.round(seek)
			if (seek) {
				state.seek = seek
			}
		},
		seekEpisode(state, seek) {
			player.seek(seek)
			seek = Math.round(seek)
			state.seek = seek
		},
		setPlaying(state, playerState) {
			state.isPlaying = playerState
		},
		setPausing(state, pauseState) {
			state.isPaused = pauseState
		},
		setBuffering(state, bufferingState) {
			state.isBuffering = bufferingState
		},
		setImage(state, image) {
			state.image = image
		},
		setEpisodeId(state, episodeId) {
			state.episodeId = episodeId
		},
		setPodcastName(state, name) {
			state.podcastName = name
		},
	},
	actions: {
		setPlaying(context, playerState) {
			context.commit('setPlaying', playerState)
		},
		setBuffering(context, bufferingState) {
			context.commit('setBuffering', bufferingState)
		},
		setVolume(context, volume) {
			context.commit('setVolume', volume)
		},
		loadVolume(context) {
			const volume = localStorage.getItem('podcast.volume')
			if (typeof volume === 'string') {
				context.commit('setVolume', volume)
			}
		},
		toggleMute(context) {
			context.commit('toggleMute')
		},
		loadEpisode(context, episode) {
			context.commit('setPodcastName', '')
			context.commit('setTitle', episode.title)
			if (episode.imgURL) {
				context.commit('setImage', episode.imgURL)
			} else {
				context.commit('setImage', episode.imgurl)
			}
			context.commit('setEpisodeId', episode.id)
			context.commit('setPausing', true)
			if (episode.podcast_id) {
				context.dispatch('setPodcastName', episode.podcast_id)
			} else {
				context.dispatch('setPodcastName', episode.podcastid)
			}
			context.commit('setDuration', episode.duration)
			if (episode.playtime) {
				context.commit('setSeek', episode.playtime)
			}
			player.load(episode.enclosure)
		},
		playEpisode(context, episode) {
			if (context.state.isPaused && episode.id === context.state.episodeId) {
				player.play()
			} else {
				context.dispatch('loadEpisode', episode)
				context.dispatch('addEpisode', episode)
				player.play()
			}
		},
		pauseEpisode(context) {
			player.pause()
		},

		setSeek(context, startTime) {
			context.commit('setSeek', startTime)
		},

		togglePlay(context) {
			if (context.state.episodeId === null) {
				return true
			}
			if (context.state.isPaused) {
				player.play()
			} else {
				player.pause()
			}
		},

		setDuration(context, duration) {
			context.commit('setDuration', duration)
		},

		seekEpisode(context, startTime) {
			context.commit('seekEpisode', startTime)
		},

		setPausing(context, state) {
			context.commit('setPausing', state)
		},

		storePlaybacktime(context, position) {
			const episodeId = context.state.episodeId
			const episode = context.getters.episodeById(episodeId)
			const episodeLastPlayed = episode.lastplayed
			const dateNow = Date.now()
			if (dateNow - episodeLastPlayed >= 5000) {
				context.dispatch('updateEpisode', { episode, playtime: position })
			}
		},

		async setPodcastName(context, podcastId) {
			const podcast = await fyydClient.queryPodcast(podcastId)
			context.commit('setPodcastName', podcast.data.title)
		},
	},
}