import {injectable, inject, BindingScope} from '@loopback/core';
import {Filter} from '@loopback/repository';
import {PatientService, UsersService} from '@sourcefuse-npm/patient-facade';
import {
  DailyCheckIns,
  EngagementExplore,
  EngagementExploreCMS,
  Explore,
  ExploreCMS,
} from '../models';
import {Cms} from './cms.service';
import {DailyCheckInsService} from './daily-check-ins-service.service';
import {MoodFactorLogsService} from './mood-factor-logs-service.service';
// sonarignore:start

const populateAll = '*';

@injectable({scope: BindingScope.TRANSIENT})
export class ExploreService {
  constructor(
    @inject('services.Cms') private cms: Cms,
    @inject('services.DailyCheckInsService')
    public dailyCheckIns: DailyCheckInsService,
    @inject('services.PatientService')
    protected patientService: PatientService,
    @inject('services.MoodFactorLogsService')
    protected moodFactorLogsService: MoodFactorLogsService,
    @inject('services.UsersService')
    protected usersService: UsersService,
  ) {}

  async explore(explore: Explore, token: string) {
    const filter: any = {};
    if (explore.reccurence) {
      filter.reccurence = {$eq: explore.reccurence};
    }

    if (explore.offsetStart) {
      filter.offset_start = {$eq: explore.offsetStart};
    }
    if (explore.offsetEnd) {
      filter.offset_end = {$eq: explore.offsetEnd};
    }

    if (explore.segmentName) {
      filter.segment_name = {$eq: explore.segmentName};
    }

    if (explore.type) {
      filter.type = {$eq: explore.type};
    }

    return this.cms.getAll('explores', token, filter, populateAll);
  }
  async getEngagementExploreById(id: number, token: string) {
    const filter: any = {};
    if (id) {
      filter.id = {
        $eq: id,
      };
    }
    const eData = await this.cms.getAll(
      'engagement-explores',
      token,
      filter,
      populateAll,
    );
    const convertedtoengagement = this.prepareEngagementExploreData(eData.data);
    return convertedtoengagement?.length
      ? convertedtoengagement[0]
      : ({} as EngagementExplore);
  }

  async engagementExplore(
    mood: string,
    moodfactor: string[],
    sleep: string,
    food: string,
    diagnosis: string,
    token: string,
  ): Promise<{data: EngagementExploreCMS[]}> {
    const filter: any = {};
    if (mood) {
      filter.mood = {
        $eq: mood,
      };
    }
    if (moodfactor?.length) {
      filter.moodFactor = {
        $in: moodfactor,
      };
    }
    if (sleep) {
      filter.sleep = {
        $eq: sleep,
      };
    }
    if (food) {
      filter.food = {
        $eq: food,
      };
    }
    if (diagnosis) {
      filter.diagnosis = {
        $eq: diagnosis,
      };
    }
    return this.cms.getAll('engagement-explores', token, filter, populateAll);
  }

  async engagementExploreRecommnded(
    mood: string,
    moodfactor: string[] | null,
    sleep: string,
    food: string,
    contentType: string[],
    diagaonosis: string,
    token: string,
    ids?: number[],
  ): Promise<{data: EngagementExploreCMS[]}[]> {
    let data: {data: EngagementExploreCMS[]}[] = [];
    const promises = [];
    if (mood) {
      const filter: any = {
        mood: {$eq: mood},
        moodFactor: {$null: true},
        sleep: {$null: true},
        food: {$null: true},
      };
      if (contentType?.length) {
        filter['$or'] = [];
        contentType.forEach(ct => {
          filter['$or'].push({
            contentType: {$eq: ct},
          });
        });
      }
      promises.push(
        this.cms.getAll('engagement-explores', token, filter, populateAll),
      );
    }
    if (moodfactor) {
      const filter: any = {
        mood: {$null: true},
        moodFactor: {$in: moodfactor},
        sleep: {$null: true},
        food: {$null: true},
      };
      if (contentType?.length) {
        filter['$or'] = [];
        contentType.forEach(ct => {
          filter['$or'].push({
            contentType: {$eq: ct},
          });
        });
      }
      promises.push(
        this.cms.getAll('engagement-explores', token, filter, populateAll),
      );
    }
    if (sleep) {
      const filter: any = {
        mood: {$null: true},
        moodFactor: {$null: true},
        sleep: {$eq: sleep},
        food: {$null: true},
      };
      if (contentType?.length) {
        filter['$or'] = [];
        contentType.forEach(ct => {
          filter['$or'].push({
            contentType: {$eq: ct},
          });
        });
      }
      promises.push(
        this.cms.getAll('engagement-explores', token, filter, populateAll),
      );
    }
    if (food) {
      const filter: any = {
        mood: {$null: true},
        moodFactor: {$null: true},
        sleep: {$null: true},
        food: {$eq: food},
      };
      if (contentType) {
        filter['$or'] = [];
        contentType.forEach(ct => {
          filter['$or'].push({
            contentType: {$eq: ct},
          });
        });
      }

      if (ids?.length) {
        const filter: any = {
          id: {$in: ids},
        };
      }
      promises.push(
        this.cms.getAll('engagement-explores', token, filter, populateAll),
      );
    }

    if (ids?.length) {
      const filter: any = {
        id: {$in: ids},
      };
      promises.push(
        this.cms.getAll('engagement-explores', token, filter, populateAll),
      );
    }

    data = await Promise.all(promises);
    return data;
  }

  async engagementExploreRecommndedMoodMoodFactor(
    mood: string,
    moodfactor: string[],
    contentType: string[],
    token: string,
  ): Promise<{data: EngagementExploreCMS[]}[]> {
    let data: {data: EngagementExploreCMS[]}[] = [];
    const promises = [];
    if (mood && moodfactor && moodfactor.length) {
      const filter: any = {
        mood: {$eq: mood},
        moodFactor: {$in: moodfactor},
        sleep: {$null: true},
        food: {$null: true},
      };
      if (contentType?.length) {
        filter['$or'] = [];
        contentType.forEach(ct => {
          filter['$or'].push({
            contentType: {$eq: ct},
          });
        });
      }
      promises.push(
        this.cms.getAll('engagement-explores', token, filter, populateAll),
      );
    }

    data = await Promise.all(promises);
    return data;
  }

  prepareEngagementExploreData(
    data: EngagementExploreCMS[],
    isUnReadPost?: boolean,
  ) {
    const convertedData: EngagementExplore[] = [];
    data.forEach(d => {
      const engagementData = this.converToEngagementExploreDataObject(d);
      engagementData.isUnReadPreviousPost = !!isUnReadPost;

      convertedData.push(engagementData);
    });
    return convertedData;
  }

  prepareExploreData(data: ExploreCMS[]) {
    const convertedData: Explore[] = [];
    data.forEach(d => {
      convertedData.push(this.converToExploreDataObject(d));
    });
    return convertedData;
  }

  converToEngagementExploreDataObject(cmsData: EngagementExploreCMS) {
    const engagementExploreDatObject: EngagementExplore =
      new EngagementExplore();
    engagementExploreDatObject.id = cmsData.id;
    if (cmsData?.attributes) {
      engagementExploreDatObject.mood = cmsData.attributes.mood;
      engagementExploreDatObject.moodFactor = cmsData.attributes.moodFactor;
      engagementExploreDatObject.sleep = cmsData.attributes.sleep;
      engagementExploreDatObject.food = cmsData.attributes.food;
      engagementExploreDatObject.content = cmsData.attributes.content;
      engagementExploreDatObject.contentType = cmsData.attributes.contentType;
      engagementExploreDatObject.diagnosis = cmsData.attributes.diagnosis;
      engagementExploreDatObject.createdAt = cmsData.attributes.createdAt;
      engagementExploreDatObject.updatedAt = cmsData.attributes.updatedAt;
      engagementExploreDatObject.publishedAt = cmsData.attributes.publishedAt;
      engagementExploreDatObject.title = cmsData.attributes.title;
      engagementExploreDatObject.content = cmsData.attributes.content;
      engagementExploreDatObject.author = cmsData.attributes.author;
      engagementExploreDatObject.duration = cmsData.attributes.duration;
      engagementExploreDatObject.symptoms = cmsData.attributes.symptoms;
      engagementExploreDatObject.contentTag = cmsData.attributes.contentTag;
      engagementExploreDatObject.image =
        cmsData.attributes.media?.data?.attributes?.url || null;
      engagementExploreDatObject.authorImage =
        cmsData.attributes.authorImage?.data?.attributes?.url || null;
    }
    return engagementExploreDatObject;
  }

  converToExploreDataObject(cmsData: ExploreCMS) {
    const engagementExploreDatObject: Explore = new Explore();
    engagementExploreDatObject.id = cmsData.id;
    if (cmsData?.attributes) {
      engagementExploreDatObject.reccurence = cmsData.attributes.reccurence;
      engagementExploreDatObject.offsetStart = cmsData.attributes.offset_start;
      engagementExploreDatObject.offsetStart = cmsData.attributes.offset_end;
      engagementExploreDatObject.type = cmsData.attributes.type;
      engagementExploreDatObject.content = cmsData.attributes.content;
      engagementExploreDatObject.segmentName = cmsData.attributes.segment_name;
      engagementExploreDatObject.title = cmsData.attributes.title;
      engagementExploreDatObject.createdAt = cmsData.attributes.createdAt;
      engagementExploreDatObject.updatedAt = cmsData.attributes.updatedAt;
      engagementExploreDatObject.publishedAt = cmsData.attributes.publishedAt;
      engagementExploreDatObject.content = cmsData.attributes.content;
      engagementExploreDatObject.author = cmsData.attributes.author;
      engagementExploreDatObject.duration = cmsData.attributes.duration;
      engagementExploreDatObject.coverImage =
        cmsData.attributes.cover_image?.data?.attributes?.url || null;
      engagementExploreDatObject.authorImage =
        cmsData.attributes.authorImage?.data?.attributes?.url || null;
      engagementExploreDatObject.engagementExplores =
        this.prepareEngagementExploreData(
          cmsData.attributes?.engagement_explores?.data,
        );
    }
    return engagementExploreDatObject;
  }

  getEngagementExplore(filter: object, token: string) {
    return this.cms.getAll('engagement-explores', token, filter, populateAll);
  }

  getExplore(filter: object, token: string) {
    return this.cms.getAll('explores', token, filter, populateAll);
  }

  async getChecinDataLatest(patientId: number, token: string) {
    const filter: Filter<DailyCheckIns> = {
      where: {
        patientId: patientId,
      },
      order: ['logDate DESC'],
      limit: 1,
    };
    const checkins = await this.dailyCheckIns.find(filter, token);

    const checkin = checkins?.length ? checkins[0] : null;

    const moodLogId = checkins.map(c => c.moodLogId);
    const moodLogs = moodLogId?.length
      ? await this.getMoods(moodLogId, token)
      : [];
    const moodFactor = checkin?.moodFactorLogId
      ? await this.getMoodFactorLogs(checkin?.moodFactorLogId as any, token)
      : [];

    const foodLogIds = checkins
      .map(m => m.foodLogId)
      .flat()
      .map(e => Number(e));
    const foodLogs = foodLogIds?.length
      ? await this.getFoods(foodLogIds, patientId, token)
      : [];

    const sleepLogIds = checkins.map(m => m.sleepLogId);
    const sleepLogs = sleepLogIds?.length
      ? await this.getSleepLogs(sleepLogIds, token)
      : [];
    return {
      mood: moodLogs?.length ? `${moodLogs[0].mood}` : '',
      moodFactor: moodFactor.map(mf => mf.moodFactor),
      sleep: sleepLogs?.length ? `${sleepLogs[0].sleep}` : '',
      food: foodLogs?.length ? `${foodLogs[0].meal}` : '',
    };
  }

  async getMoods(moodLogIds: number[], token?: string) {
    return moodLogIds.length
      ? this.patientService.getMoodsLog(
          {
            where: {
              id: {inq: moodLogIds},
            },
          },
          token,
        )
      : [];
  }

  async getFoods(foodLogIds: number[], ptainetId: number, token?: string) {
    return foodLogIds.length
      ? this.patientService.getFoodLogs(token, ptainetId, {
          where: {
            id: {inq: foodLogIds},
          },
        })
      : [];
  }

  async getSleepLogs(sleepLogIds: number[], token?: string) {
    return sleepLogIds.length
      ? this.moodFactorLogsService.getSleepLog(
          {
            where: {
              id: {inq: sleepLogIds},
            },
          },
          token,
        )
      : [];
  }

  async getMoodFactorLogs(moodlogIds: number[], token?: string) {
    return moodlogIds.length
      ? this.moodFactorLogsService.getMoodFactorsLog(
          {
            where: {
              id: {inq: moodlogIds},
            },
          },
          token,
        )
      : [];
  }
}

// sonarignore:end