backend/src/schedule/services/schedule.service.ts

import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { TuyaContext } from '@tuya/tuya-connector-nodejs';
import {
  AddScheduleDto,
  EnableScheduleDto,
  UpdateScheduleDto,
} from '../dtos/schedule.dto';
import {
  addScheduleDeviceInterface,
  getDeviceScheduleInterface,
} from '../interfaces/get.schedule.interface';

import { ProductType } from '@app/common/constants/product-type.enum';
import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
import { convertTimestampToDubaiTime } from '@app/common/helper/convertTimestampToDubaiTime';
import {
  getEnabledDays,
  getScheduleStatus,
} from '@app/common/helper/getScheduleStatus';
import { DeviceRepository } from '@app/common/modules/device/repositories';

@Injectable()
export class ScheduleService {
  private tuya: TuyaContext;
  constructor(
    private readonly configService: ConfigService,
    private readonly deviceRepository: DeviceRepository,
  ) {
    const accessKey = this.configService.get<string>('auth-config.ACCESS_KEY');
    const secretKey = this.configService.get<string>('auth-config.SECRET_KEY');
    const tuyaEuUrl = this.configService.get<string>('tuya-config.TUYA_EU_URL');
    this.tuya = new TuyaContext({
      baseUrl: tuyaEuUrl,
      accessKey,
      secretKey,
    });
  }

  async enableDeviceSchedule(
    deviceUuid: string,
    enableScheduleDto: EnableScheduleDto,
  ) {
    try {
      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);

      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
      }

      // Corrected condition for supported device types
      this.ensureProductTypeSupportedForSchedule(
        deviceDetails.productDevice.prodType as ProductType,
      );

      return this.enableScheduleDeviceInTuya(
        deviceDetails.deviceTuyaUuid,
        enableScheduleDto,
      );
    } catch (error) {
      throw new HttpException(
        error.message || 'Error While Updating Schedule',
        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }
  async deleteDeviceSchedule(deviceUuid: string, scheduleId: string) {
    try {
      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);

      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
      }

      // Corrected condition for supported device types
      this.ensureProductTypeSupportedForSchedule(
        deviceDetails.productDevice.prodType as ProductType,
      );

      return await this.deleteScheduleDeviceInTuya(
        deviceDetails.deviceTuyaUuid,
        scheduleId,
      );
    } catch (error) {
      throw new HttpException(
        error.message || 'Error While Deleting Schedule',
        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }
  async addDeviceSchedule(deviceUuid: string, addScheduleDto: AddScheduleDto) {
    try {
      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);

      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
      }

      if (
        deviceDetails.productDevice.prodType == ProductType.CUR_2 &&
        addScheduleDto.category != 'Timer'
      ) {
        throw new HttpException(
          'Invalid category for CUR_2 devices',
          HttpStatus.BAD_REQUEST,
        );
      }

      if (
        deviceDetails.productDevice.prodType == ProductType.CUR_2 &&
        addScheduleDto.category != 'Timer'
      ) {
        throw new HttpException(
          'Invalid category for CUR_2 devices',
          HttpStatus.BAD_REQUEST,
        );
      }

      this.ensureProductTypeSupportedForSchedule(
        deviceDetails.productDevice.prodType as ProductType,
      );

      await this.addScheduleDeviceInTuya(
        deviceDetails.deviceTuyaUuid,
        addScheduleDto,
        deviceDetails.productDevice.prodType as ProductType,
      );
    } catch (error) {
      throw new HttpException(
        error.message || 'Error While Adding Schedule',
        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }
  async getDeviceScheduleByCategory(deviceUuid: string, category: string) {
    try {
      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);

      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
      }
      // Corrected condition for supported device types
      this.ensureProductTypeSupportedForSchedule(
        deviceDetails.productDevice.prodType as ProductType,
      );
      const schedules = await this.getScheduleDeviceInTuya(
        deviceDetails.deviceTuyaUuid,
        category,
        deviceDetails.productDevice.prodType as ProductType,
      );
      const result = schedules.result.map((schedule: any) => {
        return {
          category:
            deviceDetails.productDevice.prodType == ProductType.CUR_2
              ? schedule.category
              : schedule.category.replace('category_', ''),
          enable: schedule.enable,
          function: {
            code: schedule.functions[0].code,
            value: schedule.functions[0].value,
          },
          time: schedule.time,
          schedule_id: schedule.timer_id,
          timezone_id: schedule.timezone_id,
          days: getEnabledDays(schedule.loops),
        };
      });
      return convertKeysToCamelCase(result);
    } catch (error) {
      throw new HttpException(
        error.message || 'Error While Adding Schedule',
        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }
  async updateDeviceSchedule(
    deviceUuid: string,
    updateScheduleDto: UpdateScheduleDto,
  ) {
    try {
      const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);

      if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
        throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
      }

      if (
        deviceDetails.productDevice.prodType == ProductType.CUR_2 &&
        updateScheduleDto.category != 'Timer'
      ) {
        throw new HttpException(
          'Invalid category for CUR_2 devices',
          HttpStatus.BAD_REQUEST,
        );
      }

      if (
        deviceDetails.productDevice.prodType == ProductType.CUR_2 &&
        updateScheduleDto.category != 'Timer'
      ) {
        throw new HttpException(
          'Invalid category for CUR_2 devices',
          HttpStatus.BAD_REQUEST,
        );
      }

      // Corrected condition for supported device types
      this.ensureProductTypeSupportedForSchedule(
        deviceDetails.productDevice.prodType as ProductType,
      );

      await this.updateScheduleDeviceInTuya(
        deviceDetails.deviceTuyaUuid,
        updateScheduleDto,
        deviceDetails.productDevice.prodType as ProductType,
      );
    } catch (error) {
      throw new HttpException(
        error.message || 'Error While Updating Schedule',
        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  private getDeviceByDeviceUuid(
    deviceUuid: string,
    withProductDevice: boolean = true,
  ) {
    return this.deviceRepository.findOne({
      where: {
        uuid: deviceUuid,
        isActive: true,
      },
      ...(withProductDevice && { relations: ['productDevice'] }),
    });
  }

  private async addScheduleDeviceInTuya(
    deviceId: string,
    addScheduleDto: AddScheduleDto,
    deviceType: ProductType,
  ): Promise<addScheduleDeviceInterface> {
    try {
      const convertedTime = convertTimestampToDubaiTime(addScheduleDto.time);
      const loops = getScheduleStatus(addScheduleDto.days);

      const path = `/v2.0/cloud/timer/device/${deviceId}`;
      const response = await this.tuya.request({
        method: 'POST',
        path,
        body: {
          time: convertedTime.time,
          timezone_id: 'Asia/Dubai',
          loops: `${loops}`,
          functions: [
            {
              ...addScheduleDto.function,
            },
          ],
          category:
            deviceType == ProductType.CUR_2
              ? addScheduleDto.category
              : `category_${addScheduleDto.category}`,
        },
      });

      return response as addScheduleDeviceInterface;
    } catch (error) {
      throw new HttpException(
        'Error adding schedule from Tuya',
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  private async getScheduleDeviceInTuya(
    deviceId: string,
    category: string,
    deviceType: ProductType,
  ): Promise<getDeviceScheduleInterface> {
    try {
      const categoryToSent =
        deviceType == ProductType.CUR_2 ? category : `category_${category}`;
      const path = `/v2.0/cloud/timer/device/${deviceId}?category=${categoryToSent}`;
      const response = await this.tuya.request({
        method: 'GET',
        path,
      });

      return response as getDeviceScheduleInterface;
    } catch (error) {
      console.error('Error fetching device schedule from Tuya:', error);

      throw new HttpException(
        'Error fetching device schedule from Tuya',
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  private async updateScheduleDeviceInTuya(
    deviceId: string,
    updateScheduleDto: UpdateScheduleDto,
    deviceType: ProductType,
  ): Promise<addScheduleDeviceInterface> {
    try {
      const convertedTime = convertTimestampToDubaiTime(updateScheduleDto.time);
      const loops = getScheduleStatus(updateScheduleDto.days);

      const path = `/v2.0/cloud/timer/device/${deviceId}`;
      const response = await this.tuya.request({
        method: 'PUT',
        path,
        body: {
          timer_id: updateScheduleDto.scheduleId,
          time: convertedTime.time,
          timezone_id: 'Asia/Dubai',
          loops: `${loops}`,
          functions: [
            {
              code: updateScheduleDto.function.code,
              value: updateScheduleDto.function.value,
            },
          ],
          category:
            deviceType == ProductType.CUR_2
              ? updateScheduleDto.category
              : `category_${updateScheduleDto.category}`,
        },
      });

      return response as addScheduleDeviceInterface;
    } catch (error) {
      throw new HttpException(
        'Error updating schedule from Tuya',
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  private async enableScheduleDeviceInTuya(
    deviceId: string,
    enableScheduleDto: EnableScheduleDto,
  ): Promise<addScheduleDeviceInterface> {
    try {
      const path = `/v2.0/cloud/timer/device/${deviceId}/state`;
      const response = await this.tuya.request({
        method: 'PUT',
        path,
        body: {
          enable: enableScheduleDto.enable,
          timer_id: enableScheduleDto.scheduleId,
        },
      });

      return response as addScheduleDeviceInterface;
    } catch (error) {
      throw new HttpException(
        'Error while updating schedule from Tuya',
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  private async deleteScheduleDeviceInTuya(
    deviceId: string,
    scheduleId: string,
  ): Promise<addScheduleDeviceInterface> {
    try {
      const path = `/v2.0/cloud/timer/device/${deviceId}/batch?timer_ids=${scheduleId}`;
      const response = await this.tuya.request({
        method: 'DELETE',
        path,
      });

      return response as addScheduleDeviceInterface;
    } catch (error) {
      throw new HttpException(
        'Error while deleting schedule from Tuya',
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }

  private ensureProductTypeSupportedForSchedule(deviceType: ProductType): void {
    if (
      ![
        ProductType.THREE_G,
        ProductType.ONE_G,
        ProductType.TWO_G,
        ProductType.WH,
        ProductType.ONE_1TG,
        ProductType.TWO_2TG,
        ProductType.THREE_3TG,
        ProductType.GD,
        ProductType.CUR_2,
      ].includes(deviceType)
    ) {
      throw new HttpException(
        'This device is not supported for schedule',
        HttpStatus.BAD_REQUEST,
      );
    }
  }
}