import { BNestBaseModuleService } from "@bish-nest/core/data/module-service/base-module.service";
import { BNestPrismaService } from "@bish-nest/core/services";
import { SystemLogService } from "@api/shared/services";
import { Injectable, NotFoundException } from "@nestjs/common";
import { SystemLogEntityType } from "@prisma/client";

@Injectable()
export class SystemSettingService extends BNestBaseModuleService {
  constructor(
    protected prisma: BNestPrismaService,
    private readonly systemLogService: SystemLogService,
  ) {
    super();
  }

  /**
   * Override add method to log creation
   */
  async add(data: any): Promise<any> {
    // Validate unique key constraint
    if (data.key) {
      const existingSetting = await this.prisma.client.systemSetting.findUnique({
        where: { key: data.key },
      });

      if (existingSetting) {
        throw new Error(`System setting with key '${data.key}' already exists`);
      }
    }

    // Validate key is not empty
    if (!data.key || data.key === '') {
      throw new Error('System setting key cannot be empty');
    }

    // Validate value is not empty
    if (!data.value || data.value === '') {
      throw new Error('System setting value cannot be empty');
    }

    // Filter out display-only audit fields (keep user relationships for database)
    const filteredData = { ...data };
    delete filteredData.user_name_created_by;
    delete filteredData.user_name_updated_by;

    const addResponse = await super.add(filteredData);
    const systemSetting = addResponse.data;

    // Log the creation
    await this.systemLogService.logInsert(
      SystemLogEntityType.SYSTEM_MODULE, // Using SYSTEM_MODULE as closest entity type
      systemSetting.id,
      systemSetting as Record<string, unknown>,
    );

    return addResponse;
  }

  /**
   * Override save method to log update
   */
  async save(id: number, data: any): Promise<any> {
    // Get old data before update
    const oldSystemSetting = await this.prisma.client.systemSetting.findUnique({
      where: { id },
    });

    if (!oldSystemSetting) {
      throw new NotFoundException(`System setting with ID ${id} not found`);
    }

    // Validate unique key constraint if key is being updated
    if (data.key && data.key !== oldSystemSetting.key) {
      const existingSetting = await this.prisma.client.systemSetting.findUnique({
        where: { key: data.key },
      });

      if (existingSetting && existingSetting.id !== id) {
        throw new Error(`System setting with key '${data.key}' already exists`);
      }
    }

    // Validate key is not empty
    if (data.key === '') {
      throw new Error('System setting key cannot be empty');
    }

    // Validate value is not empty
    if (data.value === '') {
      throw new Error('System setting value cannot be empty');
    }

    // Filter out display-only audit fields (keep userUpdatedBy for database)
    const filteredData = { ...data };
    delete filteredData.user_name_created_by;
    delete filteredData.user_name_updated_by;

    const saveResponse = await super.save(id, filteredData);
    const updatedSystemSetting = saveResponse.data;

    // Calculate changed fields and log the update
    const changedFields = SystemLogService.calculateChangedFields(
      oldSystemSetting as Record<string, unknown>,
      updatedSystemSetting as Record<string, unknown>,
    );

    await this.systemLogService.logUpdate(
      SystemLogEntityType.SYSTEM_MODULE, // Using SYSTEM_MODULE as closest entity type
      id,
      oldSystemSetting as Record<string, unknown>,
      updatedSystemSetting as Record<string, unknown>,
      changedFields,
    );

    return saveResponse;
  }

  /**
   * Override delete method to log deletion
   */
  async delete(id: number): Promise<any> {
    // Get data before deletion
    const systemSetting = await this.prisma.client.systemSetting.findUnique({
      where: { id },
    });

    if (!systemSetting) {
      throw new NotFoundException(`System setting with ID ${id} not found`);
    }

    const deleteResponse = await super.delete(id);

    // Log the deletion
    await this.systemLogService.logDelete(
      SystemLogEntityType.SYSTEM_MODULE, // Using SYSTEM_MODULE as closest entity type
      id,
      systemSetting as Record<string, unknown>,
    );

    return deleteResponse;
  }
}