import { Injectable } from "@nestjs/common";
import { InjectModel } from "@nestjs/mongoose";
import { Model, ObjectId, Types } from "mongoose";
import { UserDevice } from "./user-device.schema";
import { Response } from "express";
import { ResponseService } from "src/common/service/response.service";

@Injectable()
export class UserDevicesService {
  constructor(
    @InjectModel(UserDevice.name)
    private readonly model: Model<UserDevice>,
    private readonly resService: ResponseService,
  ) {}

  /**
   * Register or update a device token
   */
  // async registerDevice(
  //   userId: string,
  //   fcmToken: string,
  //   platform: "android" | "ios" | "web",
  // ) {
  //   try {
  //     const userObjectId = new Types.ObjectId(userId);
  //     return this.model.updateOne(
  //       { fcmToken }, // token is globally unique
  //       {
  //         $set: {
  //           userId: userObjectId,
  //           platform,
  //         },
  //       },
  //       { upsert: true },
  //     );
  //   } catch (error) {}
  // }

  async registerDevice(
    res: Response,
    userId: string,
    fcmToken: string,
    platform: "android" | "ios" | "web",
  ) {
    try {
      if (!fcmToken) {
        return this.resService.badRequest(res, "FCM token is required");
      }
      const userObjectId = new Types.ObjectId(userId);
      await this.model.updateOne(
        { fcmToken }, // globally unique
        {
          $set: {
            userId: userObjectId,
            platform,
          },
        },
        { upsert: true },
      );

      return this.resService.success(res, "", "Device registered successfully");
    } catch (error) {
      return this.resService.serverError(
        res,
        error?.message || "Failed to register device",
      );
    }
  }

  async getTokens(userId: string): Promise<string[]> {
    const userIdObj = new Types.ObjectId(userId);

    const devices = await this.model
      .find({ userId: userIdObj })
      .select("fcmToken")
      .lean();

    return devices.map((d) => d.fcmToken);
  }

  // async deleteDevice(userId: string, fcmToken: string) {
  //   const userObjectId = new Types.ObjectId(userId);

  //   return this.model.deleteOne({
  //     userId: userObjectId,
  //     fcmToken,
  //   });
  // }

  async deleteDevice(res: Response, userId: string, fcmToken: string) {
    try {
      if (!fcmToken) {
        return this.resService.badRequest(res, "FCM token is required");
      }
      const userObjectId = new Types.ObjectId(userId);
      const deleted = await this.model.deleteOne({
        userId: userObjectId,
        fcmToken,
      });

      if (deleted.deletedCount === 0) {
        return this.resService.notFound(
          res,
          "Device not found or already removed",
        );
      }

      return this.resService.success(res, "", "Device removed successfully");
    } catch (error) {
      return this.resService.serverError(
        res,
        error?.message || "Failed to delete device",
      );
    }
  }

  async removeToken(fcmToken: string) {
    return this.model.deleteOne({ fcmToken });
  }

  async removeTokens(tokens: string[]) {
    if (!tokens.length) return;

    await this.model.deleteMany({
      fcmToken: { $in: tokens },
    });
  }
}