'use strict';

const config = require('config');
const { terminal } = require('terminal-kit');
const moment = require('moment');

const networks = require('../networks.js');
const scrapers = require('./scrapers');

function accumulateIncludedSites() {
    return config.include.reduce((acc, network) => {
        // network included with specific sites, only include specified sites
        if (Array.isArray(network)) {
            const [networkId, siteIds] = network;

            return [
                ...acc,
                ...siteIds.map(siteId => ({
                    id: siteId,
                    network: networkId,
                    ...networks[networkId].sites[siteId],
                })),
            ];
        }

        // network included without further specification, include all sites
        return [
            ...acc,
            ...Object.entries(networks[network].sites).map(([siteId, site]) => ({
                id: siteId,
                network,
                ...site,
            })),
        ];
    }, []);
}

function accumulateExcludedSites() {
    return Object.entries(networks).reduce((acc, [networkId, network]) => {
        const excludedNetwork = config.exclude.find((excludedNetworkX) => {
            if (Array.isArray(excludedNetworkX)) {
                return excludedNetworkX[0] === networkId;
            }

            return excludedNetworkX === networkId;
        });

        // network excluded with specific sites, only exclude specified sites
        if (excludedNetwork && Array.isArray(excludedNetwork)) {
            const [, excludedSiteIds] = excludedNetwork;

            return [
                ...acc,
                ...Object.entries(network.sites)
                    .filter(([siteId]) => !excludedSiteIds.includes(siteId))
                    .map(([siteId, site]) => ({
                        id: siteId,
                        network: networkId,
                        ...site,
                    })),
            ];
        }

        // network excluded without further specification, exclude all its sites
        if (excludedNetwork) {
            return acc;
        }

        // network not excluded, include all its sites
        return [
            ...acc,
            ...Object.entries(network.sites).map(([siteId, site]) => ({
                id: siteId,
                network: networkId,
                ...site,
            })),
        ];
    }, []);
}

function accumulateSites() {
    return config.include ? accumulateIncludedSites() : accumulateExcludedSites();
}

async function fetchScenes(sites) {
    return Promise.all(sites.map(async (site) => {
        const scraper = scrapers[site.id] || scrapers[site.network];

        if (scraper) {
            return scraper(site);
        }

        return [];
    }));
}

function exit() {
    terminal.grabInput(false);
    terminal.clear();
    terminal.processExit();
}

async function init() {
    const sites = accumulateSites();
    const scenes = await fetchScenes(sites);

    terminal.singleColumnMenu(scenes[0].latest.map(scene => `[${scene.siteId} ${moment(scene.date).format('YYYY-MM-DD')}] ${scene.title} (${scene.actors.join(', ')}) ★ ${scene.rating.stars.toFixed(2)}`));

    terminal.on('key', (name) => {
        if (name === 'CTRL_C') {
            exit();
        }
    });
}

init();