import { Injectable, NotFoundException } from '@nestjs/common';
import { Raw, Repository } from 'typeorm';
import { InjectRepository } from '@nestjs/typeorm';
import { ApplicationUser } from 'src/entities/application-user';
import { ApplicationDashboardBodyDto } from './dto/application-dashboard.dto';
import { GeneralException } from 'src/util/general.exception';
import { Application } from 'src/entities/application';
import { ApplicationDashboard } from 'src/entities/application-dashboard';

@Injectable()
export class ApplicationDashboardService {
  constructor(
    @InjectRepository(ApplicationDashboard)
    private dashboardRepository: Repository<ApplicationDashboard>,
    @InjectRepository(Application)
    private applicationRepository: Repository<Application>,
  ) {}

  async addDashboard(applicationId: number, {
    dashboardId,
    dashboardEmbeddingId,
    dashboardName
  }: ApplicationDashboardBodyDto) {
    const application = await this.applicationRepository.countBy({ id: applicationId })

    if(!application) {
      throw new NotFoundException({ messageKey: 'application_not_found'})
    }

    const applicationDashboard = await this.dashboardRepository.countBy({
      applicationId,
      dashboardName,
    })

    if(applicationDashboard) {
      throw new GeneralException('application_dashboard_already_exists')
    }

    const saveResult = await this.dashboardRepository.insert({
      applicationId,
      dashboardId,
      dashboardName,
      dashboardEmbeddingId,
    })

    return saveResult.raw[0].id
  }

  getDashboardsByApplicationId(applicationId: number) {
    return this.dashboardRepository.find({
      where: {
        applicationId,
      },
      order: {
        dashboardName: 'ASC'
      }
    });
  }

  getDashboardsByApplicationName(applicationName: string) {
    return this.dashboardRepository.find({
      where: {
        application: {
          translations: {
            name: Raw(alias => `LOWER(${alias}) LIKE LOWER(:value)`, {
              value: applicationName
            })
          }
        },
      },
      order: {
        dashboardName: 'ASC'
      }
    });
  }

  async enable(applicationId: number, id: number): Promise<ApplicationDashboard> {
    const dashboard = await this.dashboardRepository.findOneBy({ id, applicationId })
    if(!dashboard) {
      throw new NotFoundException({ messageKey: 'application_dashboard_not_found'})
    }

    return this.dashboardRepository.save({
      ...dashboard,
      enabled: true,
      enabledAt: new Date(),
    })
  }

  async disable(applicationId: number, id: number): Promise<ApplicationDashboard> {
    const dashboard = await this.dashboardRepository.findOneBy({ id, applicationId })
    if(!dashboard) {
      throw new NotFoundException({ messageKey: 'application_dashboard_not_found'})
    }

    return this.dashboardRepository.save({
      ...dashboard,
      enabled: false,
    })
  }

  async delete(applicationId: number, id: number) {
    const dashboard = await this.dashboardRepository.countBy({ applicationId, id })

    if (!dashboard) {
      throw new NotFoundException({ messageKey: 'application_dashboard_not_found'})
    }

    await this.dashboardRepository.delete({ applicationId, id });
  }
}