import { graphql, get } from '../api';
import {
	releaseFields,
} from '../fragments';
import { curateTag } from '../curate';
import getDateRange from '../get-date-range';

function initTagsActions(store, _router) {
	async function fetchTagBySlug({ _commit }, { tagSlug, limit = 100, range = 'latest' }) {
		const { before, after, orderBy } = getDateRange(range);

		const { tagBySlug } = await graphql(`
            query Tag(
                $tagSlug:String!
                $limit:Int = 1000,
                $after:Date = "1900-01-01",
                $before:Date = "2100-01-01",
                $orderBy: [ReleasesTagsOrderBy!],
                $exclude: [String!]
            ) {
                tagBySlug(slug:$tagSlug) {
                    id
                    name
                    slug
                    description
                    group {
                        name
                        slug
                    }
                    poster: tagsPosterByTagId {
                        media {
                            id
                            thumbnail
                            path
                            comment
                            sfw: sfwMedia {
                                id
                                thumbnail
                                path
                                comment
                            }
                        }
                    }
                    photos: tagsPhotos {
                        media {
                            id
                            thumbnail
                            lazy
                            path
                            comment
                            sfw: sfwMedia {
                                id
                                thumbnail
                                lazy
                                path
                                comment
                            }
                        }
                    }
                    releases: releasesTags(
                        filter: {
                            release: {
                                date: {
                                    lessThan: $before,
                                    greaterThan: $after,
                                },
                                releasesTags: {
                                    none: {
                                        tag: {
                                            slug: {
                                                in: $exclude
                                            }
                                        }
                                    }
                                }
                            }
                        },
                        first: $limit,
                        orderBy: $orderBy,
                    ) {
                        release {
                            ${releaseFields}
                        }
                    }
                }
            }
        `, {
			tagSlug,
			limit,
			after,
			before,
			orderBy: orderBy === 'DATE_DESC' ? 'RELEASE_BY_RELEASE_ID__DATE_DESC' : 'RELEASE_BY_RELEASE_ID__DATE_ASC',
			exclude: store.state.ui.filter,
		});

		return curateTag(tagBySlug, store);
	}

	async function fetchTags({ _commit }, {
		limit = 100,
		slugs = [],
		_group,
		_priority,
	}) {
		const { tags } = await graphql(`
            query Tags(
                $slugs: [String!] = [],
                $limit: Int = 100
            ) {
                tags(
                    filter: { slug: { in: $slugs } },
                    first: $limit
                ) {
                    id
                    name
                    slug
                    poster: tagsPosterByTagId {
                        media {
                            thumbnail
                            comment
                            lazy
                            sfw: sfwMedia {
                                thumbnail
                                comment
                                lazy
                            }
                        }
                    }
                    group {
                        name
                        slug
                    }
                }
            }
        `, {
			slugs,
			limit,
		});

		return tags.map(tag => curateTag(tag, store.state.ui.sfw));
	}

	async function fetchTagReleases({ _commit }, tagId) {
		const releases = await get(`/tags/${tagId}/releases`, {
			filter: store.state.ui.filter,
			after: store.getters.after,
			before: store.getters.before,
		});

		return releases;
	}

	return {
		fetchTagBySlug,
		fetchTags,
		fetchTagReleases,
	};
}

export default initTagsActions;