'use strict';

/**
 *  update-item controller
 */

const { createCoreController } = require('@strapi/strapi').factories;

module.exports = createCoreController('api::update-item.update-item', ({ strapi }) => ({
  async create(ctx) {
    ctx.request.body.data.submittedBy = ctx.state.user;
    ctx.request.body.data.SubmittedAt = new Date();

    return super.create(ctx);
  },
  async update(ctx) {
    // console.log(ctx.state.user.role.name);
    let response;
    switch (ctx.state.user.role.name) {
      case 'Public':
      case 'Authenticated':
      case 'Contributor':
        // Remove operation should be intact
        if (ctx.request.body.data.submittedBy.id !== ctx.state.user.id) {
          const sanitizedEntity = await this.sanitizeOutput(null, ctx);
          response = this.transformResponse(sanitizedEntity);
        } else {
          ctx.request.body.data.updatedBy = ctx.state.user.id;
          ctx.request.body.data.UpdateSubmissionTimestamp = new Date();
          response = await super.update(ctx);
        }
        break;

      case 'Maintainer':
      case 'Administrator':
        // Handle the review comment and
        // If ReviewAt field is null, should be set. Otherwise it continues;
        // Apply review operation
        // const entity = await strapi.service('api::update-item.update-item').findOne(ctx.params.id);
        // console.log(entity);
        ctx.request.body.data.updatedBy = ctx.state.user.id;
        ctx.request.body.data.UpdateSubmissionTimestamp = new Date();
        response = await super.update(ctx);
        break;
    }

    return response;
  },
  // This updateReview function is called by only either Maintainer or Administrator
  async updateReview(ctx) {
    // console.log('update info')
    let response;
    switch (ctx.state.user.role.name) {
      case 'Public':
      case 'Authenticated':
      case 'Contributor':
        // Remove operation should be intact
        const sanitizedEntity = await this.sanitizeOutput(null, ctx);
        response = this.transformResponse(sanitizedEntity);
        break;

      case 'Maintainer':
      case 'Administrator':
        // Handle the review comment and
        // If ReviewAt field is null, should be set. Otherwise it continues;
        // Apply review operation
        // const entity = await strapi.service('api::update-item.update-item').findOne(ctx.params.id);
        // console.log(entity);
        const now = new Date();
        if (ctx.request.body.data.ReviewedAt === null) {
          ctx.request.body.data.ReviewedAt = now;
        }
        ctx.request.body.data.reviewedBy = ctx.state.user.id;
        ctx.request.body.data.UpdateReviewTimestamp = now;
        response = await super.update(ctx);
        break;
    }

    return response;
  },
  async find(ctx) {
    // console.log(ctx.state.user.role.name);
    ctx.query['populate'] = ['submittedBy', 'reviewedBy'];

    switch (ctx.state.user.role.name) {
      case 'Public':
      case 'Authenticated':
      case 'Contributor':
        // Remove operation should be intact
        ctx.query['filters'] = { submittedBy: ctx.state.user.id };
        break;

      case 'Maintainer':
      case 'Administrator':
        // Handle the review comment and
        // If ReviewAt field is null, should be set. Otherwise it continues;
        // Apply review operation
        // const entity = await strapi.service('api::update-item.update-item').findOne(ctx.params.id);
        // console.log(entity);
        break;
    }
    // console.log(ctx.query)

    return super.find(ctx)
  },
  async filterProteinOrCondensateRequest(ctx) {

    // return ctx.send('Hello World!');

    console.log();

    let res;
    switch (ctx.state.user.role.name) {
      case 'Public':
      case 'Authenticated':
        // res = await strapi.db.query('api::update-item.update-item').findMany({
        //   where: {
        //     EntityId: {
        //       $contains: ctx.params.id
        //     }
        //   },
        // });
        ctx.query["filters"] = {
          ...ctx.query["filters"],
          EntityId: {
            $contains: ctx.params.id,
          },

        };
        res = super.find(ctx)
        break
      case 'Contributor':
        // Remove operation should be intact
       
        ctx.query["filters"] = {
          ...ctx.query["filters"], submittedBy: ctx.state.user.id, EntityId: {
            $contains: ctx.params.id,
          }
        }
        // res = await strapi.db.query('api::update-item.update-item').findMany({
        //
        //   where: {
        //     submittedBy: ctx.state.user.id,
        //     EntityId: {
        //       $contains: ctx.params.id
        //     }
        //   },
        // });
        res = super.find(ctx)
        break;

      case 'Maintainer':
        // console.log(ctx)
        // console.log(ctx.params)
        ctx.query["filters"] = {
          ...ctx.query["filters"],
          EntityId: {
            $contains: ctx.params.id,
          },

        };
        // res= await strapi.entityService.findMany('api::update-item.update-item', {
        //   start: 10,
        //   limit: 15,
        //   filters: {
        //     EntityId: {
        //       $contains: ctx.params.id,
        //     },
        //   },
        // });
        res = super.find(ctx)
        break;
      case 'Administrator':
        // Handle the review comment and
        // If ReviewAt field is null, should be set. Otherwise it continues;
        // Apply review operation
        // const entity = await strapi.service('api::update-item.update-item').findOne(ctx.params.id);
        // console.log(entity);
        ctx.query["filters"] = {
          ...ctx.query["filters"],
          EntityId: {
            $contains: ctx.params.id,
          },

        };
        res = super.find(ctx)
        break;
    }
    console.log(res);
    return res
  },
  async findOne(ctx) {
    // console.log(ctx);
    const { id } = ctx.params;
    const { query } = ctx;
    query['populate'] = ['submittedBy', 'reviewedBy'];

    let entity = await strapi.service("api::update-item.update-item").findOne(id, query);
    // console.log(entity);

    switch (ctx.state.user.role.name) {
      case 'Public':
      case 'Authenticated':
      case 'Contributor':
        if (entity.submittedBy === null || entity.submittedBy.id !== ctx.state.user.id) {
          entity = null;
        }
        break;

      case 'Maintainer':
      case 'Administrator':
        break;
    }

    const sanitizedEntity = await this.sanitizeOutput(entity, ctx);

    return this.transformResponse(sanitizedEntity);
  }

}));