import { forwardRef, Inject, Injectable } from '@nestjs/common';
import { EntityTableRepository } from '../repository/entity-table.repository';
import { EntityTableColumnRepository } from '../repository/entity-table-column.repository';
import { EntityTableDto } from '../dto/entity-table.dto';
import { DISPLAY_LIST } from '../../../constant/global.constant';
import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
import { SavedFilterRepositoryService } from 'src/module/filter/repository/saved-filter.repository';

@Injectable()
export class EntityTableService {
  constructor(
    private entityTableRepository: EntityTableRepository,
    private readonly entityTableColumnRepository: EntityTableColumnRepository,

    @Inject(forwardRef(() => 'ListMasterService'))
    @Inject('ListMasterService')
    private readonly listMasterService: ListMasterService,

    private readonly savedFilterRepoService: SavedFilterRepositoryService,
  ) {}

  async getEntityData(mappedEntityType: string | null, loggedInUser) {
    if (mappedEntityType) {
      const tableMaster =
        await this.entityTableRepository.findByMappedEntityType(
          mappedEntityType,
          loggedInUser.enterprise_id,
        );

      if (!tableMaster) {
        throw new Error(
          `Entity with mappedEntityType "${mappedEntityType}" not found.`,
        );
      }

      return tableMaster;
    } else {
      throw new Error();
    }
  }

  async findByEntityTypeAndListType(entityType: string, listType: string) {
    return await this.entityTableRepository.findByEntityTypeAndListType(
      entityType,
      listType,
    );
  }

  async findByEntityTypeAndListTypeAndDisplayType(
    entityType: string,
    listType: string,
    displayType: string,
    enterprise_id: number,
  ) {
    return await this.entityTableRepository.findByEntityTypeAndListTypeAndDisplayType(
      entityType,
      listType,
      displayType,
      enterprise_id,
    );
  }

  async getTableMetaDataForListing(
    entityType: string,
    listType: string,
    loggedInUser: any,
  ) {
    return await this.getTableMetaData(
      entityType,
      listType,
      DISPLAY_LIST,
      loggedInUser,
    );
  }

  async getTableMetaData(
    entityType: string,
    listType: string,
    displayType: string,
    loggedInUser: any,
  ) {
    const entityTable = await this.findByEntityTypeAndListTypeAndDisplayType(
      entityType,
      listType,
      displayType,
      loggedInUser?.enterprise_id,
    );
    const entityTableDto = entityTable as EntityTableDto;
    if (entityTable) {
      entityTableDto.column_list =
        await this.entityTableColumnRepository.findByParentIdAndParentType(
          entityTable.id,
          entityTable.entity_type,
          loggedInUser.enterprise_id,
        );
      entityTableDto.operation_list = {
        text: await this.listMasterService.getDropdownOptions(
          'OPT',
          {},
          [],
          loggedInUser,
        ),
        number: await this.listMasterService.getDropdownOptions(
          'OPN',
          {},
          [],
          loggedInUser,
        ),
        date: await this.listMasterService.getDropdownOptions(
          'OPD',
          {},
          [],
          loggedInUser,
        ),
        select: await this.listMasterService.getDropdownOptions(
          'OPS',
          {},
          [],
          loggedInUser,
        ),
        multiselect: await this.listMasterService.getDropdownOptions(
          'OPM',
          {},
          [],
          loggedInUser,
        ),
        year: await this.listMasterService.getDropdownOptions(
          'OPY',
          {},
          [],
          loggedInUser,
        ),
        // Add any other operations you want to include
      };
      entityTableDto.default_filter =
        await this.savedFilterRepoService.getDefaultFilterByEntityType(
          entityTable.list_type,
        );
      if (loggedInUser.id) {
        entityTableDto.saved_filter =
          await this.savedFilterRepoService.getSavedFiltersByUserIdAndEntityType(
            loggedInUser,
            entityTable.list_type,
          );
      }
      if (loggedInUser.id) {
        entityTableDto.shared_filter =
          await this.savedFilterRepoService.getSharedFiltersByLevelTypeAndLevelId(
            loggedInUser,
            entityTable.list_type,
          );
      }
    }

    return entityTableDto;
  }
}