import { Injectable } from '@nestjs/common';
import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
import { In, Repository } from 'typeorm';
import { MapperRepository } from '../repository/mapper.repository';
import { FieldMapperRepository } from '../repository/field-mapper.repository';
import { FieldLovsRepository } from '../repository/field-lovs.repository';
import { InjectRepository } from '@nestjs/typeorm';
import { ListMasterItems } from '../../listmaster/entity/list-master-items.entity';

@Injectable()
export class MapperService extends EntityServiceImpl {
  constructor(
    private mapperRepository: MapperRepository,
    private fieldMapperRepository: FieldMapperRepository,
    private fieldLovsRepository: FieldLovsRepository,
    @InjectRepository(ListMasterItems)
    private readonly listMasterItemsRepo: Repository<ListMasterItems>,
  ) {
    super();
  }

  async getByMappedEntityType(mappedEntityType: string, loggedInUser, filter?: string, status?: string) {
    if (!mappedEntityType) return [];

    const mappers = await this.mapperRepository.findByMappedEntityType(mappedEntityType, loggedInUser.enterprise_id, filter);

    const distinctStatuses = [
      ...new Set(mappers.map((m) => m.status).filter((s) => s !== null)),
    ];

    // get all statuses in one query
    const statusMap = new Map();
    if (distinctStatuses.length > 0) {

      const statuses = await this.listMasterItemsRepo.find({
        where: {
          id: In(distinctStatuses),
        },
      });

      statuses.forEach((status) => {
        statusMap.set(status.id, status.name);
      });
    }

    // map status names to mappers

    let mappersResolved = mappers.map((m) => ({
      id: m.id,
      label: m.name,
      value: m.id,
      code: m.code,
      status: statusMap.get(m.status) || null,
    }));

    if (status) {
      mappersResolved = mappersResolved.filter(
        (m) => m.status && m.status.toLowerCase() === status.toLowerCase(),
      );
    }
    return mappersResolved;
  }

  async deleteEntity(entityType: string, entityId: number, loggedInUser) {
    let fieldMappers =
      await this.fieldMapperRepository.findByMapperId(entityId);

    for (const fieldMapper of fieldMappers) {
      await this.fieldLovsRepository.deleteByMapperFieldId(fieldMapper.id);
    }

    await this.fieldMapperRepository.deleteByMapperId(entityId);

    await super.deleteEntity(entityType, entityId, loggedInUser);
    return {
      success: true,
      message: `Mapper deleted successfully.`,
    };
  }
}