/* global Venue */
'use strict';

const _ = require('lodash');
const moment = require('moment');
const { generateService, parseParamsToFindOptions } = require('../../helpers/service.helper');
const Sequelize = require('sequelize');
const models = require('../../core/models');


const multimediaComposer = (multimedias) => multimedias.map(multimedia => ({
    ...multimedia,
    ...multimedia.MultimediaFile,
    type: multimedia.type,
    media_type: multimedia.MultimediaFile.type,
    MultimediaFile: undefined,
    createdAt: undefined,
    updatedAt: undefined,
    userId: undefined,
}));

const speakerComposer = (speaker, context) => {
    delete speaker.createdAt;
    delete speaker.updatedAt;
    return {...speaker,
        multimedias: multimediaComposer(speaker.multimedias),
    }
}

const eventComposer = (event, context) => {

    if (context.scopes.includes('includeVenue')) {    
        delete event.venue.updatedAt;
        delete event.venue.createdAt;    
    };

    let multimedias = []
    if (context.scopes.includes('includeMultimedias')) { 
        multimedias = multimediaComposer(event.multimedias)
    };       

    let speakers = []
    if (context.scopes.includes('includeSpeakers')) {
        speakers = event.details.map((detail) => ({
            order: detail.order,
            ... speakerComposer(detail.speaker),
        }))
    };

    return Object.assign({},
        event,
        { multimedias: multimedias },
        { details: undefined },
        { speakers: speakers }
    )
};


const extraMethods = {
    afterFetchAll: (result, params, context) => {
      
        if (!result.count) {
            return result;
        }

        let rows = result.rows.map(row => row.toJSON());
        rows = rows.map(event => eventComposer(event, context));
        
        return {
            count: rows.length,
            rows: rows
        }
    },


    afterFetchOne: (result, params, context) => {
        return eventComposer(result.toJSON(), context);
    },

/*
    fetchOne: async (params, context) => {
        const findOptions = parseParamsToFindOptions(params);
        
        // Incluir
        findOptions.include.push({
            model: models.EventDetail,
            as: 'details',
            include: {
                model: models.Speaker,
                as: 'speaker',
                attributes: ['id', 'name', 'description']
            }
        });
        findOptions.include.push({
            model: models.EventType,
            as: 'type',
            attributes: ['name', 'title'],
        });
        findOptions.include.push({
            model: models.Venue,
            as: 'venue'
        });

        findOptions.include.push({
            model: models.EventInscription,
            as: 'inscriptions'
        });


        findOptions.where = Object.assign({},
            findOptions.where, {
                state: 'publish'
        });

        return await models.Event.findOne({
            where: findOptions.where,
            include: findOptions.include
        });
    },
*/    
};

module.exports = generateService(models.Event, extraMethods);