import ApplicationSerializer from './application';
import classic from 'ember-classic-decorator';

/*
  There’s no grouping of recommendations on the server, so this
  processes a list of recommendations and groups them by task
  group.
*/

@classic
export default class RecommendationSummarySerializer extends ApplicationSerializer {
  normalizeArrayResponse(store, modelClass, payload) {
    const recommendationSerializer = store.serializerFor('recommendation');
    const RecommendationModel = store.modelFor('recommendation');

    const slugToSummaryObject = {};
    const allRecommendations = [];

    payload.forEach(recommendationHash => {
      const slug = `${JSON.stringify([recommendationHash.JobID, recommendationHash.Namespace])}/${
        recommendationHash.Group
      }`;

      if (!slugToSummaryObject[slug]) {
        slugToSummaryObject[slug] = {
          attributes: {
            jobId: recommendationHash.JobID,
            jobNamespace: recommendationHash.Namespace,
            taskGroupName: recommendationHash.Group,
          },
          recommendations: [],
        };
      }

      slugToSummaryObject[slug].recommendations.push(recommendationHash);
      allRecommendations.push(recommendationHash);
    });

    return {
      data: Object.values(slugToSummaryObject).map(summaryObject => {
        const latest = Math.max(...summaryObject.recommendations.mapBy('SubmitTime'));

        return {
          type: 'recommendation-summary',
          id: summaryObject.recommendations
            .mapBy('ID')
            .sort()
            .join('-'),
          attributes: {
            ...summaryObject.attributes,
            submitTime: new Date(Math.floor(latest / 1000000)),
          },
          relationships: {
            job: {
              data: {
                type: 'job',
                id: JSON.stringify([
                  summaryObject.attributes.jobId,
                  summaryObject.attributes.jobNamespace,
                ]),
              },
            },
            recommendations: {
              data: summaryObject.recommendations.map(r => {
                return {
                  type: 'recommendation',
                  id: r.ID,
                };
              }),
            },
          },
        };
      }),
      included: allRecommendations.map(
        recommendationHash =>
          recommendationSerializer.normalize(RecommendationModel, recommendationHash).data
      ),
    };
  }

  normalizeUpdateRecordResponse(store, primaryModelClass, payload, id) {
    return {
      data: {
        id,
        attributes: {
          isProcessed: true,
        },
      },
    };
  }
}