const txtgen = require('txtgen');
const casual = require('casual');
const nanoid = require('nanoid');

const capitalize = require('../src/utils/capitalize');
const slugify = require('../src/utils/slugify');

async function updateReleasesSearch(releaseIds, knex) {
    const documents = await knex.raw(`
        SELECT
            releases.id as release_id,
            to_tsvector(
                releases.title || ' ' ||
                sites.name || ' ' ||
                sites.slug || ' ' ||
                replace(CAST(releases.date AS VARCHAR), '-', ' ') || ' ' ||
                string_agg(actors.name, ' ') || ' ' ||
                string_agg(tags.name, ' ')
            ) as document
        FROM releases
        LEFT JOIN releases_actors AS local_actors ON local_actors.release_id = releases.id
        JOIN releases_tags AS local_tags ON local_tags.release_id = releases.id
        JOIN sites ON releases.site_id = sites.id
        LEFT JOIN actors ON local_actors.actor_id = actors.id
        JOIN tags ON local_tags.tag_id = tags.id
        GROUP BY releases.id, sites.name, sites.slug;
    `);

    const query = knex('releases_search').insert(documents.rows).toString();
    return knex.raw(`${query} ON CONFLICT (release_id) DO UPDATE SET document = EXCLUDED.document`);
}

exports.seed = async knex => Promise.resolve()
    .then(async () => {
        const [sites, tags, media] = await Promise.all([
            knex('sites').select('*'),
            knex('tags').select('*').where('alias_for', null),
            knex('media').select('*'),
        ]);

        const releases = Array.from({ length: 1000 }, () => {
            const title = txtgen.sentence();
            const site = casual.random_value(sites);

            return {
                entry_id: nanoid(),
                title,
                slug: slugify(title, { limit: 50 }),
                site_id: site.id,
                date: new Date(Math.random() * (new Date().getTime() - 1500000000000) + 1500000000000),
                batch: 'dummy',
            };
        });

        const actors = Array.from({ length: 100 }, () => {
            const name = capitalize(casual.full_name);
            const slug = slugify(name);

            return {
                name,
                slug,
                gender: casual.random_element(['male', 'female']),
            };
        });

        const uniqueActors = Object.values(actors.reduce((acc, actor) => ({ ...acc, [actor.slug]: actor }), {}));

        const releaseIds = await knex('releases').insert(releases).returning('id');
        const actorIds = await knex('actors').insert(uniqueActors).returning('id');

        const actorAssociations = releaseIds.map((releaseId) => {
            const releaseActorIds = Array.from({ length: Math.floor(Math.random() * 3) + 1 }, () => casual.random_value(actorIds));

            return Array.from(new Set(releaseActorIds)).map(actorId => ({ release_id: releaseId, actor_id: actorId }));
        }).flat();

        const tagAssociations = releaseIds.map((releaseId) => {
            const releaseTags = Array.from({ length: Math.floor(Math.random() * 20) }, () => casual.random_value(tags));

            return Array.from(new Set(releaseTags)).map(tag => ({ release_id: releaseId, tag_id: tag.id }));
        }).flat();

        const posterAssociations = releaseIds.map(releaseId => ({
            release_id: releaseId,
            media_id: casual.random_value(media).id,
        }));

        await Promise.all([
            knex('releases_actors').insert(actorAssociations),
            knex('releases_tags').insert(tagAssociations),
            knex('releases_posters').insert(posterAssociations),
        ]);

        await updateReleasesSearch(releaseIds, knex);
    });